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 /************************************************************************
 288 *
 289 * ixjdebug meanings are now bit mapped instead of level based
 290 * Values can be or'ed together to turn on multiple messages
 291 *
 292 * bit  0 (0x0001) = any failure
 293 * bit  1 (0x0002) = general messages
 294 * bit  2 (0x0004) = POTS ringing related
 295 * bit  3 (0x0008) = PSTN events
 296 * bit  4 (0x0010) = PSTN Cadence state details
 297 * bit  5 (0x0020) = Tone detection triggers
 298 * bit  6 (0x0040) = Tone detection cadence details
 299 * bit  7 (0x0080) = ioctl tracking
 300 * bit  8 (0x0100) = signal tracking
 301 * bit  9 (0x0200) = CallerID generation details
 302 *
 303 ************************************************************************/
 304
 305 #ifdef IXJ_DYN_ALLOC
 306
 307 static IXJ *ixj[IXJMAX];
 308 #define get_ixj(b)      ixj[(b)]
 309
 310 /*
 311  *      Allocate a free IXJ device
 312  */
 313
 314 static IXJ *ixj_alloc()
 315 {
 316         for(cnt=0; cnt<IXJMAX; cnt++)
 317         {
 318                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 319                 {
 320                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 321                         if (j == NULL)
 322                                 return NULL;
 323                         ixj[cnt] = j;
 324                         return j;
 325                 }
 326         }
 327         return NULL;
 328 }
 329
 330 static void ixj_fsk_free(IXJ *j)
 331 {
 332         kfree(j->fskdata);
 333         j->fskdata = NULL;
 334 }
 335
 336 static void ixj_fsk_alloc(IXJ *j)
 337 {
 338         if(!j->fskdata) {
 339                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 340                 if (!j->fskdata) {
 341                         if(ixjdebug & 0x0200) {
 342                                 printk("IXJ phone%d - allocate failed\n", j->board);
 343                         }
 344                         return;
 345                 } else {
 346                         j->fsksize = 8000;
 347                         if(ixjdebug & 0x0200) {
 348                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 349                         }
 350                 }
 351         }
 352 }
 353
 354 #else
 355
 356 static IXJ ixj[IXJMAX];
 357 #define get_ixj(b)      (&ixj[(b)])
 358
 359 /*
 360  *      Allocate a free IXJ device
 361  */
 362
 363 static IXJ *ixj_alloc(void)
 364 {
 365         int cnt;
 366         for(cnt=0; cnt<IXJMAX; cnt++) {
 367                 if(!ixj[cnt].DSPbase)
 368                         return &ixj[cnt];
 369         }
 370         return NULL;
 371 }
 372
 373 static inline void ixj_fsk_free(IXJ *j) {;}
 374
 375 static inline void ixj_fsk_alloc(IXJ *j)
 376 {
 377         j->fsksize = 8000;
 378 }
 379
 380 #endif
 381
 382 #ifdef PERFMON_STATS
 383 #define ixj_perfmon(x)  ((x)++)
 384 #else
 385 #define ixj_perfmon(x)  do { } while(0)
 386 #endif
 387
 388 static int ixj_convert_loaded;
 389
 390 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 391
 392 /************************************************************************
 393 *
 394 * These are function definitions to allow external modules to register
 395 * enhanced functionality call backs.
 396 *
 397 ************************************************************************/
 398
 399 static int Stub(IXJ * J, unsigned long arg)
 400 {
 401         return 0;
 402 }
 403
 404 static IXJ_REGFUNC ixj_PreRead = &Stub;
 405 static IXJ_REGFUNC ixj_PostRead = &Stub;
 406 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 407 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 408
 409 static void ixj_read_frame(IXJ *j);
 410 static void ixj_write_frame(IXJ *j);
 411 static void ixj_init_timer(IXJ *j);
 412 static void ixj_add_timer(IXJ * j);
 413 static void ixj_timeout(unsigned long ptr);
 414 static int read_filters(IXJ *j);
 415 static int LineMonitor(IXJ *j);
 416 static int ixj_fasync(int fd, struct file *, int mode);
 417 static int ixj_set_port(IXJ *j, int arg);
 418 static int ixj_set_pots(IXJ *j, int arg);
 419 static int ixj_hookstate(IXJ *j);
 420 static int ixj_record_start(IXJ *j);
 421 static void ixj_record_stop(IXJ *j);
 422 static void set_rec_volume(IXJ *j, int volume);
 423 static int get_rec_volume(IXJ *j);
 424 static int set_rec_codec(IXJ *j, int rate);
 425 static void ixj_vad(IXJ *j, int arg);
 426 static int ixj_play_start(IXJ *j);
 427 static void ixj_play_stop(IXJ *j);
 428 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 429 static int ixj_set_tone_off(unsigned short, IXJ *j);
 430 static int ixj_play_tone(IXJ *j, char tone);
 431 static void ixj_aec_start(IXJ *j, int level);
 432 static int idle(IXJ *j);
 433 static void ixj_ring_on(IXJ *j);
 434 static void ixj_ring_off(IXJ *j);
 435 static void aec_stop(IXJ *j);
 436 static void ixj_ringback(IXJ *j);
 437 static void ixj_busytone(IXJ *j);
 438 static void ixj_dialtone(IXJ *j);
 439 static void ixj_cpt_stop(IXJ *j);
 440 static char daa_int_read(IXJ *j);
 441 static char daa_CR_read(IXJ *j, int cr);
 442 static int daa_set_mode(IXJ *j, int mode);
 443 static int ixj_linetest(IXJ *j);
 444 static int ixj_daa_write(IXJ *j);
 445 static int ixj_daa_cid_read(IXJ *j);
 446 static void DAA_Coeff_US(IXJ *j);
 447 static void DAA_Coeff_UK(IXJ *j);
 448 static void DAA_Coeff_France(IXJ *j);
 449 static void DAA_Coeff_Germany(IXJ *j);
 450 static void DAA_Coeff_Australia(IXJ *j);
 451 static void DAA_Coeff_Japan(IXJ *j);
 452 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 453 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 454 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 455 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 456 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 457 /* Serial Control Interface funtions */
 458 static int SCI_Control(IXJ *j, int control);
 459 static int SCI_Prepare(IXJ *j);
 460 static int SCI_WaitHighSCI(IXJ *j);
 461 static int SCI_WaitLowSCI(IXJ *j);
 462 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 463 static int ixj_PCcontrol_wait(IXJ *j);
 464 static void ixj_pre_cid(IXJ *j);
 465 static void ixj_write_cid(IXJ *j);
 466 static void ixj_write_cid_bit(IXJ *j, int bit);
 467 static int set_base_frame(IXJ *j, int size);
 468 static int set_play_codec(IXJ *j, int rate);
 469 static void set_rec_depth(IXJ *j, int depth);
 470 static int ixj_mixer(long val, IXJ *j);
 471
 472 /************************************************************************
 473 CT8020/CT8021 Host Programmers Model
 474 Host address    Function                                        Access
 475 DSPbase +
 476 0-1             Aux Software Status Register (reserved)         Read Only
 477 2-3             Software Status Register                        Read Only
 478 4-5             Aux Software Control Register (reserved)        Read Write
 479 6-7             Software Control Register                       Read Write
 480 8-9             Hardware Status Register                        Read Only
 481 A-B             Hardware Control Register                       Read Write
 482 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 483 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 484 ************************************************************************/
 485
 486 static inline void ixj_read_HSR(IXJ *j)
 487 {
 488         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 489         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 490 }
 491
 492 static inline int IsControlReady(IXJ *j)
 493 {
 494         ixj_read_HSR(j);
 495         return j->hsr.bits.controlrdy ? 1 : 0;
 496 }
 497
 498 static inline int IsPCControlReady(IXJ *j)
 499 {
 500         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 501         return j->pccr1.bits.crr ? 1 : 0;
 502 }
 503
 504 static inline int IsStatusReady(IXJ *j)
 505 {
 506         ixj_read_HSR(j);
 507         return j->hsr.bits.statusrdy ? 1 : 0;
 508 }
 509
 510 static inline int IsRxReady(IXJ *j)
 511 {
 512         ixj_read_HSR(j);
 513         ixj_perfmon(j->rxreadycheck);
 514         return j->hsr.bits.rxrdy ? 1 : 0;
 515 }
 516
 517 static inline int IsTxReady(IXJ *j)
 518 {
 519         ixj_read_HSR(j);
 520         ixj_perfmon(j->txreadycheck);
 521         return j->hsr.bits.txrdy ? 1 : 0;
 522 }
 523
 524 static inline void set_play_volume(IXJ *j, int volume)
 525 {
 526         if (ixjdebug & 0x0002)
 527                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 528         ixj_WriteDSPCommand(0xCF02, j);
 529         ixj_WriteDSPCommand(volume, j);
 530 }
 531
 532 static int set_play_volume_linear(IXJ *j, int volume)
 533 {
 534         int newvolume, dspplaymax;
 535
 536         if (ixjdebug & 0x0002)
 537                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 538         if(volume > 100 || volume < 0) {
 539                 return -1;
 540         }
 541
 542         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 543         switch (j->cardtype) {
 544         case QTI_PHONEJACK:
 545                 dspplaymax = 0x380;
 546                 break;
 547         case QTI_LINEJACK:
 548                 if(j->port == PORT_PSTN) {
 549                         dspplaymax = 0x48;
 550                 } else {
 551                         dspplaymax = 0x100;
 552                 }
 553                 break;
 554         case QTI_PHONEJACK_LITE:
 555                 dspplaymax = 0x380;
 556                 break;
 557         case QTI_PHONEJACK_PCI:
 558                 dspplaymax = 0x6C;
 559                 break;
 560         case QTI_PHONECARD:
 561                 dspplaymax = 0x50;
 562                 break;
 563         default:
 564                 return -1;
 565         }
 566         newvolume = (dspplaymax * volume) / 100;
 567         set_play_volume(j, newvolume);
 568         return 0;
 569 }
 570
 571 static inline void set_play_depth(IXJ *j, int depth)
 572 {
 573         if (depth > 60)
 574                 depth = 60;
 575         if (depth < 0)
 576                 depth = 0;
 577         ixj_WriteDSPCommand(0x5280 + depth, j);
 578 }
 579
 580 static inline int get_play_volume(IXJ *j)
 581 {
 582         ixj_WriteDSPCommand(0xCF00, j);
 583         return j->ssr.high << 8 | j->ssr.low;
 584 }
 585
 586 static int get_play_volume_linear(IXJ *j)
 587 {
 588         int volume, newvolume, dspplaymax;
 589
 590         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 591         switch (j->cardtype) {
 592         case QTI_PHONEJACK:
 593                 dspplaymax = 0x380;
 594                 break;
 595         case QTI_LINEJACK:
 596                 if(j->port == PORT_PSTN) {
 597                         dspplaymax = 0x48;
 598                 } else {
 599                         dspplaymax = 0x100;
 600                 }
 601                 break;
 602         case QTI_PHONEJACK_LITE:
 603                 dspplaymax = 0x380;
 604                 break;
 605         case QTI_PHONEJACK_PCI:
 606                 dspplaymax = 0x6C;
 607                 break;
 608         case QTI_PHONECARD:
 609                 dspplaymax = 100;
 610                 break;
 611         default:
 612                 return -1;
 613         }
 614         volume = get_play_volume(j);
 615         newvolume = (volume * 100) / dspplaymax;
 616         if(newvolume > 100)
 617                 newvolume = 100;
 618         return newvolume;
 619 }
 620
 621 static inline BYTE SLIC_GetState(IXJ *j)
 622 {
 623         if (j->cardtype == QTI_PHONECARD) {
 624                 j->pccr1.byte = 0;
 625                 j->psccr.bits.dev = 3;
 626                 j->psccr.bits.rw = 1;
 627                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 628                 ixj_PCcontrol_wait(j);
 629                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 630                 ixj_PCcontrol_wait(j);
 631                 if (j->pslic.bits.powerdown)
 632                         return PLD_SLIC_STATE_OC;
 633                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 634                         return PLD_SLIC_STATE_ACTIVE;
 635                 else
 636                         return PLD_SLIC_STATE_RINGING;
 637         } else {
 638                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 639         }
 640         return j->pld_slicr.bits.state;
 641 }
 642
 643 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
 644 {
 645         BOOL fRetVal = FALSE;
 646
 647         if (j->cardtype == QTI_PHONECARD) {
 648                 if (j->flags.pcmciasct) {
 649                         switch (byState) {
 650                         case PLD_SLIC_STATE_TIPOPEN:
 651                         case PLD_SLIC_STATE_OC:
 652                                 j->pslic.bits.powerdown = 1;
 653                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 654                                 fRetVal = TRUE;
 655                                 break;
 656                         case PLD_SLIC_STATE_RINGING:
 657                                 if (j->readers || j->writers) {
 658                                         j->pslic.bits.powerdown = 0;
 659                                         j->pslic.bits.ring0 = 1;
 660                                         j->pslic.bits.ring1 = 0;
 661                                         fRetVal = TRUE;
 662                                 }
 663                                 break;
 664                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 665
 666                         case PLD_SLIC_STATE_STANDBY:
 667                         case PLD_SLIC_STATE_ACTIVE:
 668                                 if (j->readers || j->writers) {
 669                                         j->pslic.bits.powerdown = 0;
 670                                 } else {
 671                                         j->pslic.bits.powerdown = 1;
 672                                 }
 673                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 674                                 fRetVal = TRUE;
 675                                 break;
 676                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 677
 678                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 679
 680                         default:
 681                                 fRetVal = FALSE;
 682                                 break;
 683                         }
 684                         j->psccr.bits.dev = 3;
 685                         j->psccr.bits.rw = 0;
 686                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 687                         ixj_PCcontrol_wait(j);
 688                 }
 689         } else {
 690                 /* Set the C1, C2, C3 & B2EN signals. */
 691                 switch (byState) {
 692                 case PLD_SLIC_STATE_OC:
 693                         j->pld_slicw.bits.c1 = 0;
 694                         j->pld_slicw.bits.c2 = 0;
 695                         j->pld_slicw.bits.c3 = 0;
 696                         j->pld_slicw.bits.b2en = 0;
 697                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 698                         fRetVal = TRUE;
 699                         break;
 700                 case PLD_SLIC_STATE_RINGING:
 701                         j->pld_slicw.bits.c1 = 1;
 702                         j->pld_slicw.bits.c2 = 0;
 703                         j->pld_slicw.bits.c3 = 0;
 704                         j->pld_slicw.bits.b2en = 1;
 705                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 706                         fRetVal = TRUE;
 707                         break;
 708                 case PLD_SLIC_STATE_ACTIVE:
 709                         j->pld_slicw.bits.c1 = 0;
 710                         j->pld_slicw.bits.c2 = 1;
 711                         j->pld_slicw.bits.c3 = 0;
 712                         j->pld_slicw.bits.b2en = 0;
 713                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 714                         fRetVal = TRUE;
 715                         break;
 716                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 717
 718                         j->pld_slicw.bits.c1 = 1;
 719                         j->pld_slicw.bits.c2 = 1;
 720                         j->pld_slicw.bits.c3 = 0;
 721                         j->pld_slicw.bits.b2en = 0;
 722                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 723                         fRetVal = TRUE;
 724                         break;
 725                 case PLD_SLIC_STATE_TIPOPEN:
 726                         j->pld_slicw.bits.c1 = 0;
 727                         j->pld_slicw.bits.c2 = 0;
 728                         j->pld_slicw.bits.c3 = 1;
 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_STANDBY:
 734                         j->pld_slicw.bits.c1 = 1;
 735                         j->pld_slicw.bits.c2 = 0;
 736                         j->pld_slicw.bits.c3 = 1;
 737                         j->pld_slicw.bits.b2en = 1;
 738                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 739                         fRetVal = TRUE;
 740                         break;
 741                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 742
 743                         j->pld_slicw.bits.c1 = 0;
 744                         j->pld_slicw.bits.c2 = 1;
 745                         j->pld_slicw.bits.c3 = 1;
 746                         j->pld_slicw.bits.b2en = 0;
 747                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 748                         fRetVal = TRUE;
 749                         break;
 750                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 751
 752                         j->pld_slicw.bits.c1 = 1;
 753                         j->pld_slicw.bits.c2 = 1;
 754                         j->pld_slicw.bits.c3 = 1;
 755                         j->pld_slicw.bits.b2en = 0;
 756                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 757                         fRetVal = TRUE;
 758                         break;
 759                 default:
 760                         fRetVal = FALSE;
 761                         break;
 762                 }
 763         }
 764
 765         return fRetVal;
 766 }
 767
 768 static int ixj_wink(IXJ *j)
 769 {
 770         BYTE slicnow;
 771
 772         slicnow = SLIC_GetState(j);
 773
 774         j->pots_winkstart = jiffies;
 775         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 776
 777         msleep(jiffies_to_msecs(j->winktime));
 778
 779         SLIC_SetState(slicnow, j);
 780         return 0;
 781 }
 782
 783 static void ixj_init_timer(IXJ *j)
 784 {
 785         init_timer(&j->timer);
 786         j->timer.function = ixj_timeout;
 787         j->timer.data = (unsigned long)j;
 788 }
 789
 790 static void ixj_add_timer(IXJ *j)
 791 {
 792         j->timer.expires = jiffies + (hertz / samplerate);
 793         add_timer(&j->timer);
 794 }
 795
 796 static void ixj_tone_timeout(IXJ *j)
 797 {
 798         IXJ_TONE ti;
 799
 800         j->tone_state++;
 801         if (j->tone_state == 3) {
 802                 j->tone_state = 0;
 803                 if (j->cadence_t) {
 804                         j->tone_cadence_state++;
 805                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 806                                 switch (j->cadence_t->termination) {
 807                                 case PLAY_ONCE:
 808                                         ixj_cpt_stop(j);
 809                                         break;
 810                                 case REPEAT_LAST_ELEMENT:
 811                                         j->tone_cadence_state--;
 812                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 813                                         break;
 814                                 case REPEAT_ALL:
 815                                         j->tone_cadence_state = 0;
 816                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 817                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 818                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 819                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 820                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 821                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 822                                                 ixj_init_tone(j, &ti);
 823                                         }
 824                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 825                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 826                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 827                                         break;
 828                                 }
 829                         } else {
 830                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 831                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 832                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 833                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 834                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 835                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 836                                         ixj_init_tone(j, &ti);
 837                                 }
 838                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 839                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 840                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 841                         }
 842                 }
 843         }
 844 }
 845
 846 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 847 {
 848         if(j->ixj_signals[event]) {
 849                 if(ixjdebug & 0x0100)
 850                         printk("Sending signal for event %d\n", event);
 851                         /* Send apps notice of change */
 852                 /* see config.h for macro definition */
 853                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 854         }
 855 }
 856
 857 static void ixj_pstn_state(IXJ *j)
 858 {
 859         int var;
 860         union XOPXR0 XR0, daaint;
 861
 862         var = 10;
 863
 864         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 865         daaint.reg = 0;
 866         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 867
 868         j->pld_scrr.byte = inb_p(j->XILINXbase);
 869         if (j->pld_scrr.bits.daaflag) {
 870                 daa_int_read(j);
 871                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 872                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 873                                 daaint.bitreg.RING = 1;
 874                                 if(ixjdebug & 0x0008) {
 875                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 876                                 }
 877                         } else {
 878                                 daa_set_mode(j, SOP_PU_RESET);
 879                         }
 880                 }
 881                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 882                         daaint.bitreg.Caller_ID = 1;
 883                         j->pstn_cid_intr = 1;
 884                         j->pstn_cid_received = jiffies;
 885                         if(ixjdebug & 0x0008) {
 886                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 887                         }
 888                 }
 889                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 890                         daaint.bitreg.Cadence = 1;
 891                         if(ixjdebug & 0x0008) {
 892                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 893                         }
 894                 }
 895                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 896                         daaint.bitreg.VDD_OK = 1;
 897                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 898                 }
 899         }
 900         daa_CR_read(j, 1);
 901         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)) {
 902                 daaint.bitreg.RMR = 1;
 903                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 904                 if(ixjdebug & 0x0008) {
 905                         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);
 906                 }
 907                 j->pstn_prev_rmr = j->pstn_last_rmr;
 908                 j->pstn_last_rmr = jiffies;
 909         }
 910         switch(j->daa_mode) {
 911                 case SOP_PU_SLEEP:
 912                         if (daaint.bitreg.RING) {
 913                                 if (!j->flags.pstn_ringing) {
 914                                         if (j->daa_mode != SOP_PU_RINGING) {
 915                                                 j->pstn_ring_int = jiffies;
 916                                                 daa_set_mode(j, SOP_PU_RINGING);
 917                                         }
 918                                 }
 919                         }
 920                         break;
 921                 case SOP_PU_RINGING:
 922                         if (daaint.bitreg.RMR) {
 923                                 if (ixjdebug & 0x0008) {
 924                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 925                                 }
 926                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 927                                         j->flags.pstn_rmr = 1;
 928                                         j->pstn_ring_start = jiffies;
 929                                         j->pstn_ring_stop = 0;
 930                                         j->ex.bits.pstn_ring = 0;
 931                                         if (j->cadence_f[4].state == 0) {
 932                                                 j->cadence_f[4].state = 1;
 933                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 934                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 935                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 936                                         } else if (j->cadence_f[4].state == 2) {
 937                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 938                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 939                                                         if (j->cadence_f[4].on2) {
 940                                                                 j->cadence_f[4].state = 3;
 941                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 942                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 943                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 944                                                         } else {
 945                                                                 j->cadence_f[4].state = 7;
 946                                                         }
 947                                                 } else {
 948                                                         if (ixjdebug & 0x0008) {
 949                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 950                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 951                                                                                 j->cadence_f[4].off1);
 952                                                         }
 953                                                         j->cadence_f[4].state = 0;
 954                                                 }
 955                                         } else if (j->cadence_f[4].state == 4) {
 956                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 957                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 958                                                         if (j->cadence_f[4].on3) {
 959                                                                 j->cadence_f[4].state = 5;
 960                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 961                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 962                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 963                                                         } else {
 964                                                                 j->cadence_f[4].state = 7;
 965                                                         }
 966                                                 } else {
 967                                                         if (ixjdebug & 0x0008) {
 968                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 969                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 970                                                                                 j->cadence_f[4].off2);
 971                                                         }
 972                                                         j->cadence_f[4].state = 0;
 973                                                 }
 974                                         } else if (j->cadence_f[4].state == 6) {
 975                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 976                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 977                                                         j->cadence_f[4].state = 7;
 978                                                 } else {
 979                                                         if (ixjdebug & 0x0008) {
 980                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 981                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 982                                                                                 j->cadence_f[4].off3);
 983                                                         }
 984                                                         j->cadence_f[4].state = 0;
 985                                                 }
 986                                         } else {
 987                                                 j->cadence_f[4].state = 0;
 988                                         }
 989                                 } else {                                /* Falling edge of RMR */
 990                                         j->pstn_ring_start = 0;
 991                                         j->pstn_ring_stop = jiffies;
 992                                         if (j->cadence_f[4].state == 1) {
 993                                                 if(!j->cadence_f[4].on1) {
 994                                                         j->cadence_f[4].state = 7;
 995                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
 996                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
 997                                                         if (j->cadence_f[4].off1) {
 998                                                                 j->cadence_f[4].state = 2;
 999                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1000                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1001                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1002                                                         } else {
1003                                                                 j->cadence_f[4].state = 7;
1004                                                         }
1005                                                 } else {
1006                                                         if (ixjdebug & 0x0008) {
1007                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1008                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1009                                                                                 j->cadence_f[4].on1);
1010                                                         }
1011                                                         j->cadence_f[4].state = 0;
1012                                                 }
1013                                         } else if (j->cadence_f[4].state == 3) {
1014                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1015                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1016                                                         if (j->cadence_f[4].off2) {
1017                                                                 j->cadence_f[4].state = 4;
1018                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1019                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1020                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1021                                                         } else {
1022                                                                 j->cadence_f[4].state = 7;
1023                                                         }
1024                                                 } else {
1025                                                         if (ixjdebug & 0x0008) {
1026                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1027                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1028                                                                                 j->cadence_f[4].on2);
1029                                                         }
1030                                                         j->cadence_f[4].state = 0;
1031                                                 }
1032                                         } else if (j->cadence_f[4].state == 5) {
1033                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1034                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1035                                                         if (j->cadence_f[4].off3) {
1036                                                                 j->cadence_f[4].state = 6;
1037                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1038                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1039                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1040                                                         } else {
1041                                                                 j->cadence_f[4].state = 7;
1042                                                         }
1043                                                 } else {
1044                                                         j->cadence_f[4].state = 0;
1045                                                 }
1046                                         } else {
1047                                                 if (ixjdebug & 0x0008) {
1048                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1049                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1050                                                                         j->cadence_f[4].on3);
1051                                                 }
1052                                                 j->cadence_f[4].state = 0;
1053                                         }
1054                                 }
1055                                 if (ixjdebug & 0x0010) {
1056                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1057                                 }
1058                                 if (ixjdebug & 0x0010) {
1059                                         switch(j->cadence_f[4].state) {
1060                                                 case 1:
1061                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1062                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1063                                                         break;
1064                                                 case 2:
1065                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1066                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1067                                                         break;
1068                                                 case 3:
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].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1071                                                         break;
1072                                                 case 4:
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].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1075                                                         break;
1076                                                 case 5:
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].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1079                                                         break;
1080                                                 case 6:
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].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1083                                                         break;
1084                                         }
1085                                 }
1086                         }
1087                         if (j->cadence_f[4].state == 7) {
1088                                 j->cadence_f[4].state = 0;
1089                                 j->pstn_ring_stop = jiffies;
1090                                 j->ex.bits.pstn_ring = 1;
1091                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1092                                 if(ixjdebug & 0x0008) {
1093                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1094                                 }
1095                         }
1096                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1097                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1098                                 if(ixjdebug & 0x0008) {
1099                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1100                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1101                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1102                                 }
1103                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1104                                 daa_set_mode(j, SOP_PU_SLEEP);
1105                         }
1106                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1107                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1108                                 ixj_daa_cid_read(j);
1109                                 j->ex.bits.caller_id = 1;
1110                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1111                                 j->pstn_cid_intr = 0;
1112                         }
1113                         if (daaint.bitreg.Cadence) {
1114                                 if(ixjdebug & 0x0008) {
1115                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1116                                 }
1117                                 daa_set_mode(j, SOP_PU_SLEEP);
1118                                 j->ex.bits.pstn_ring = 0;
1119                         }
1120                         break;
1121                 case SOP_PU_CONVERSATION:
1122                         if (daaint.bitreg.VDD_OK) {
1123                                 if(!daaint.bitreg.SI_0) {
1124                                         if (!j->pstn_winkstart) {
1125                                                 if(ixjdebug & 0x0008) {
1126                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1127                                                 }
1128                                                 j->pstn_winkstart = jiffies;
1129                                         }
1130                                 } else {
1131                                         if (j->pstn_winkstart) {
1132                                                 if(ixjdebug & 0x0008) {
1133                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1134                                                 }
1135                                                 j->pstn_winkstart = 0;
1136                                         }
1137                                 }
1138                         }
1139                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1140                                 if(ixjdebug & 0x0008) {
1141                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1142                                 }
1143                                 daa_set_mode(j, SOP_PU_SLEEP);
1144                                 j->pstn_winkstart = 0;
1145                                 j->ex.bits.pstn_wink = 1;
1146                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1147                         }
1148                         break;
1149         }
1150 }
1151
1152 static void ixj_timeout(unsigned long ptr)
1153 {
1154         int board;
1155         unsigned long jifon;
1156         IXJ *j = (IXJ *)ptr;
1157         board = j->board;
1158
1159         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1160                 ixj_perfmon(j->timerchecks);
1161                 j->hookstate = ixj_hookstate(j);
1162                 if (j->tone_state) {
1163                         if (!(j->hookstate)) {
1164                                 ixj_cpt_stop(j);
1165                                 if (j->m_hook) {
1166                                         j->m_hook = 0;
1167                                         j->ex.bits.hookstate = 1;
1168                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1169                                 }
1170                                 clear_bit(board, &j->busyflags);
1171                                 ixj_add_timer(j);
1172                                 return;
1173                         }
1174                         if (j->tone_state == 1)
1175                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1176                         else
1177                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1178                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1179                                 if (j->tone_state == 1) {
1180                                         ixj_play_tone(j, j->tone_index);
1181                                         if (j->dsp.low == 0x20) {
1182                                                 clear_bit(board, &j->busyflags);
1183                                                 ixj_add_timer(j);
1184                                                 return;
1185                                         }
1186                                 } else {
1187                                         ixj_play_tone(j, 0);
1188                                         if (j->dsp.low == 0x20) {
1189                                                 clear_bit(board, &j->busyflags);
1190                                                 ixj_add_timer(j);
1191                                                 return;
1192                                         }
1193                                 }
1194                         } else {
1195                                 ixj_tone_timeout(j);
1196                                 if (j->flags.dialtone) {
1197                                         ixj_dialtone(j);
1198                                 }
1199                                 if (j->flags.busytone) {
1200                                         ixj_busytone(j);
1201                                         if (j->dsp.low == 0x20) {
1202                                                 clear_bit(board, &j->busyflags);
1203                                                 ixj_add_timer(j);
1204                                                 return;
1205                                         }
1206                                 }
1207                                 if (j->flags.ringback) {
1208                                         ixj_ringback(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->tone_state) {
1216                                         ixj_cpt_stop(j);
1217                                 }
1218                         }
1219                 }
1220                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1221                         if (IsRxReady(j)) {
1222                                 ixj_read_frame(j);
1223                         }
1224                         if (IsTxReady(j)) {
1225                                 ixj_write_frame(j);
1226                         }
1227                 }
1228                 if (j->flags.cringing) {
1229                         if (j->hookstate & 1) {
1230                                 j->flags.cringing = 0;
1231                                 ixj_ring_off(j);
1232                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1233                                 switch(j->cadence_f[5].state) {
1234                                         case 0:
1235                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1236                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1237                                                         if(ixjdebug & 0x0004) {
1238                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1239                                                         }
1240                                                         ixj_ring_on(j);
1241                                                 }
1242                                                 j->cadence_f[5].state = 1;
1243                                                 break;
1244                                         case 1:
1245                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1246                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1247                                                         if(ixjdebug & 0x0004) {
1248                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1249                                                         }
1250                                                         ixj_ring_off(j);
1251                                                         j->cadence_f[5].state = 2;
1252                                                 }
1253                                                 break;
1254                                         case 2:
1255                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1256                                                         if(ixjdebug & 0x0004) {
1257                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1258                                                         }
1259                                                         ixj_ring_on(j);
1260                                                         if (j->cadence_f[5].on2) {
1261                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1262                                                                 j->cadence_f[5].state = 3;
1263                                                         } else {
1264                                                                 j->cadence_f[5].state = 7;
1265                                                         }
1266                                                 }
1267                                                 break;
1268                                         case 3:
1269                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1270                                                         if(ixjdebug & 0x0004) {
1271                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1272                                                         }
1273                                                         ixj_ring_off(j);
1274                                                         if (j->cadence_f[5].off2) {
1275                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1276                                                                 j->cadence_f[5].state = 4;
1277                                                         } else {
1278                                                                 j->cadence_f[5].state = 7;
1279                                                         }
1280                                                 }
1281                                                 break;
1282                                         case 4:
1283                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1284                                                         if(ixjdebug & 0x0004) {
1285                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1286                                                         }
1287                                                         ixj_ring_on(j);
1288                                                         if (j->cadence_f[5].on3) {
1289                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1290                                                                 j->cadence_f[5].state = 5;
1291                                                         } else {
1292                                                                 j->cadence_f[5].state = 7;
1293                                                         }
1294                                                 }
1295                                                 break;
1296                                         case 5:
1297                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1298                                                         if(ixjdebug & 0x0004) {
1299                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1300                                                         }
1301                                                         ixj_ring_off(j);
1302                                                         if (j->cadence_f[5].off3) {
1303                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1304                                                                 j->cadence_f[5].state = 6;
1305                                                         } else {
1306                                                                 j->cadence_f[5].state = 7;
1307                                                         }
1308                                                 }
1309                                                 break;
1310                                         case 6:
1311                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1312                                                         if(ixjdebug & 0x0004) {
1313                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1314                                                         }
1315                                                         j->cadence_f[5].state = 7;
1316                                                 }
1317                                                 break;
1318                                         case 7:
1319                                                 if(ixjdebug & 0x0004) {
1320                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321                                                 }
1322                                                 j->flags.cidring = 1;
1323                                                 j->cadence_f[5].state = 0;
1324                                                 break;
1325                                 }
1326                                 if (j->flags.cidring && !j->flags.cidsent) {
1327                                         j->flags.cidsent = 1;
1328                                         if(j->fskdcnt) {
1329                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1330                                                 ixj_pre_cid(j);
1331                                         }
1332                                         j->flags.cidring = 0;
1333                                 }
1334                                 clear_bit(board, &j->busyflags);
1335                                 ixj_add_timer(j);
1336                                 return;
1337                         } else {
1338                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1339                                         if (j->flags.cidring && !j->flags.cidsent) {
1340                                                 j->flags.cidsent = 1;
1341                                                 if(j->fskdcnt) {
1342                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1343                                                         ixj_pre_cid(j);
1344                                                 }
1345                                                 j->flags.cidring = 0;
1346                                         }
1347                                         j->ring_cadence_t--;
1348                                         if (j->ring_cadence_t == -1)
1349                                                 j->ring_cadence_t = 15;
1350                                         j->ring_cadence_jif = jiffies;
1351
1352                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1353                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1354                                                         j->flags.firstring = 1;
1355                                                 else
1356                                                         ixj_ring_on(j);
1357                                         } else {
1358                                                 ixj_ring_off(j);
1359                                                 if(!j->flags.cidsent)
1360                                                         j->flags.cidring = 1;
1361                                         }
1362                                 }
1363                                 clear_bit(board, &j->busyflags);
1364                                 ixj_add_timer(j);
1365                                 return;
1366                         }
1367                 }
1368                 if (!j->flags.ringing) {
1369                         if (j->hookstate) { /* & 1) { */
1370                                 if (j->dsp.low != 0x20 &&
1371                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1372                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1373                                 }
1374                                 LineMonitor(j);
1375                                 read_filters(j);
1376                                 ixj_WriteDSPCommand(0x511B, j);
1377                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1378                                 if (!j->m_hook && (j->hookstate & 1)) {
1379                                         j->m_hook = j->ex.bits.hookstate = 1;
1380                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1381                                 }
1382                         } else {
1383                                 if (j->ex.bits.dtmf_ready) {
1384                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1385                                 }
1386                                 if (j->m_hook) {
1387                                         j->m_hook = 0;
1388                                         j->ex.bits.hookstate = 1;
1389                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1390                                 }
1391                         }
1392                 }
1393                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1394                         ixj_pstn_state(j);
1395                 }
1396                 if (j->ex.bytes) {
1397                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1398                 }
1399                 clear_bit(board, &j->busyflags);
1400         }
1401         ixj_add_timer(j);
1402 }
1403
1404 static int ixj_status_wait(IXJ *j)
1405 {
1406         unsigned long jif;
1407
1408         jif = jiffies + ((60 * hertz) / 100);
1409         while (!IsStatusReady(j)) {
1410                 ixj_perfmon(j->statuswait);
1411                 if (time_after(jiffies, jif)) {
1412                         ixj_perfmon(j->statuswaitfail);
1413                         return -1;
1414                 }
1415         }
1416         return 0;
1417 }
1418
1419 static int ixj_PCcontrol_wait(IXJ *j)
1420 {
1421         unsigned long jif;
1422
1423         jif = jiffies + ((60 * hertz) / 100);
1424         while (!IsPCControlReady(j)) {
1425                 ixj_perfmon(j->pcontrolwait);
1426                 if (time_after(jiffies, jif)) {
1427                         ixj_perfmon(j->pcontrolwaitfail);
1428                         return -1;
1429                 }
1430         }
1431         return 0;
1432 }
1433
1434 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1435 {
1436         BYTES bytes;
1437         unsigned long jif;
1438
1439         atomic_inc(&j->DSPWrite);
1440         if(atomic_read(&j->DSPWrite) > 1) {
1441                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1442                 return -1;
1443         }
1444         bytes.high = (cmd & 0xFF00) >> 8;
1445         bytes.low = cmd & 0x00FF;
1446         jif = jiffies + ((60 * hertz) / 100);
1447         while (!IsControlReady(j)) {
1448                 ixj_perfmon(j->iscontrolready);
1449                 if (time_after(jiffies, jif)) {
1450                         ixj_perfmon(j->iscontrolreadyfail);
1451                         atomic_dec(&j->DSPWrite);
1452                         if(atomic_read(&j->DSPWrite) > 0) {
1453                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1454                                 while(atomic_read(&j->DSPWrite) > 0) {
1455                                         atomic_dec(&j->DSPWrite);
1456                                 }
1457                         }
1458                         return -1;
1459                 }
1460         }
1461         outb(bytes.low, j->DSPbase + 6);
1462         outb(bytes.high, j->DSPbase + 7);
1463
1464         if (ixj_status_wait(j)) {
1465                 j->ssr.low = 0xFF;
1466                 j->ssr.high = 0xFF;
1467                 atomic_dec(&j->DSPWrite);
1468                 if(atomic_read(&j->DSPWrite) > 0) {
1469                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1470                         while(atomic_read(&j->DSPWrite) > 0) {
1471                                 atomic_dec(&j->DSPWrite);
1472                         }
1473                 }
1474                 return -1;
1475         }
1476 /* Read Software Status Register */
1477         j->ssr.low = inb_p(j->DSPbase + 2);
1478         j->ssr.high = inb_p(j->DSPbase + 3);
1479         atomic_dec(&j->DSPWrite);
1480         if(atomic_read(&j->DSPWrite) > 0) {
1481                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1482                 while(atomic_read(&j->DSPWrite) > 0) {
1483                         atomic_dec(&j->DSPWrite);
1484                 }
1485         }
1486         return 0;
1487 }
1488
1489 /***************************************************************************
1490 *
1491 *  General Purpose IO Register read routine
1492 *
1493 ***************************************************************************/
1494 static inline int ixj_gpio_read(IXJ *j)
1495 {
1496         if (ixj_WriteDSPCommand(0x5143, j))
1497                 return -1;
1498
1499         j->gpio.bytes.low = j->ssr.low;
1500         j->gpio.bytes.high = j->ssr.high;
1501
1502         return 0;
1503 }
1504
1505 static inline void LED_SetState(int state, IXJ *j)
1506 {
1507         if (j->cardtype == QTI_LINEJACK) {
1508                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1509                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1510                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1511                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1512
1513                 outb(j->pld_scrw.byte, j->XILINXbase);
1514         }
1515 }
1516
1517 /*********************************************************************
1518 *  GPIO Pins are configured as follows on the Quicknet Internet
1519 *  PhoneJACK Telephony Cards
1520 *
1521 * POTS Select        GPIO_6=0 GPIO_7=0
1522 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1523 * Handset Select     GPIO_6=1 GPIO_7=0
1524 *
1525 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1526 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1527 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1528 *
1529 * Hook Switch changes reported on GPIO_3
1530 *********************************************************************/
1531 static int ixj_set_port(IXJ *j, int arg)
1532 {
1533         if (j->cardtype == QTI_PHONEJACK_LITE) {
1534                 if (arg != PORT_POTS)
1535                         return 10;
1536                 else
1537                         return 0;
1538         }
1539         switch (arg) {
1540         case PORT_POTS:
1541                 j->port = PORT_POTS;
1542                 switch (j->cardtype) {
1543                 case QTI_PHONECARD:
1544                         if (j->flags.pcmciasct == 1)
1545                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1546                         else
1547                                 return 11;
1548                         break;
1549                 case QTI_PHONEJACK_PCI:
1550                         j->pld_slicw.pcib.mic = 0;
1551                         j->pld_slicw.pcib.spk = 0;
1552                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1553                         break;
1554                 case QTI_LINEJACK:
1555                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1556                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1557                                                                            Software Control Register */
1558                                 return 2;
1559                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1560
1561                         outb(j->pld_scrw.byte, j->XILINXbase);
1562                         j->pld_clock.byte = 0;
1563                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1564                         j->pld_slicw.bits.rly1 = 1;
1565                         j->pld_slicw.bits.spken = 0;
1566                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1567                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1568                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1569                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1570                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1571                         ixj_mixer(0x0E80, j);   /*Mic mute */
1572                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1573                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1574                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1575                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1576 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1577                         break;
1578                 case QTI_PHONEJACK:
1579                         j->gpio.bytes.high = 0x0B;
1580                         j->gpio.bits.gpio6 = 0;
1581                         j->gpio.bits.gpio7 = 0;
1582                         ixj_WriteDSPCommand(j->gpio.word, j);
1583                         break;
1584                 }
1585                 break;
1586         case PORT_PSTN:
1587                 if (j->cardtype == QTI_LINEJACK) {
1588                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1589
1590                         j->pld_slicw.bits.rly3 = 0;
1591                         j->pld_slicw.bits.rly1 = 1;
1592                         j->pld_slicw.bits.spken = 0;
1593                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1594                         j->port = PORT_PSTN;
1595                 } else {
1596                         return 4;
1597                 }
1598                 break;
1599         case PORT_SPEAKER:
1600                 j->port = PORT_SPEAKER;
1601                 switch (j->cardtype) {
1602                 case QTI_PHONECARD:
1603                         if (j->flags.pcmciasct) {
1604                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1605                         }
1606                         break;
1607                 case QTI_PHONEJACK_PCI:
1608                         j->pld_slicw.pcib.mic = 1;
1609                         j->pld_slicw.pcib.spk = 1;
1610                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1611                         break;
1612                 case QTI_LINEJACK:
1613                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1614                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1615                                                                            Software Control Register */
1616                                 return 2;
1617                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1618
1619                         outb(j->pld_scrw.byte, j->XILINXbase);
1620                         j->pld_clock.byte = 0;
1621                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1622                         j->pld_slicw.bits.rly1 = 1;
1623                         j->pld_slicw.bits.spken = 1;
1624                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1625                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1626                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1627                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1628                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1629                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1630                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1631                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1632                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1633                         break;
1634                 case QTI_PHONEJACK:
1635                         j->gpio.bytes.high = 0x0B;
1636                         j->gpio.bits.gpio6 = 0;
1637                         j->gpio.bits.gpio7 = 1;
1638                         ixj_WriteDSPCommand(j->gpio.word, j);
1639                         break;
1640                 }
1641                 break;
1642         case PORT_HANDSET:
1643                 if (j->cardtype != QTI_PHONEJACK) {
1644                         return 5;
1645                 } else {
1646                         j->gpio.bytes.high = 0x0B;
1647                         j->gpio.bits.gpio6 = 1;
1648                         j->gpio.bits.gpio7 = 0;
1649                         ixj_WriteDSPCommand(j->gpio.word, j);
1650                         j->port = PORT_HANDSET;
1651                 }
1652                 break;
1653         default:
1654                 return 6;
1655                 break;
1656         }
1657         return 0;
1658 }
1659
1660 static int ixj_set_pots(IXJ *j, int arg)
1661 {
1662         if (j->cardtype == QTI_LINEJACK) {
1663                 if (arg) {
1664                         if (j->port == PORT_PSTN) {
1665                                 j->pld_slicw.bits.rly1 = 0;
1666                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1667                                 j->flags.pots_pstn = 1;
1668                                 return 1;
1669                         } else {
1670                                 j->flags.pots_pstn = 0;
1671                                 return 0;
1672                         }
1673                 } else {
1674                         j->pld_slicw.bits.rly1 = 1;
1675                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1676                         j->flags.pots_pstn = 0;
1677                         return 1;
1678                 }
1679         } else {
1680                 return 0;
1681         }
1682 }
1683
1684 static void ixj_ring_on(IXJ *j)
1685 {
1686         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1687          {
1688                 if (ixjdebug & 0x0004)
1689                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1690
1691                 j->gpio.bytes.high = 0x0B;
1692                 j->gpio.bytes.low = 0x00;
1693                 j->gpio.bits.gpio1 = 1;
1694                 j->gpio.bits.gpio2 = 1;
1695                 j->gpio.bits.gpio5 = 0;
1696                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1697         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1698         {
1699                 if (ixjdebug & 0x0004)
1700                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1701
1702                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1703         }
1704 }
1705
1706 static int ixj_siadc(IXJ *j, int val)
1707 {
1708         if(j->cardtype == QTI_PHONECARD){
1709                 if(j->flags.pcmciascp){
1710                         if(val == -1)
1711                                 return j->siadc.bits.rxg;
1712
1713                         if(val < 0 || val > 0x1F)
1714                                 return -1;
1715
1716                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1717                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1718                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1719                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1720                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1721                         j->psccr.bits.dev = 0;
1722                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1723                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1724                         ixj_PCcontrol_wait(j);
1725                         return j->siadc.bits.rxg;
1726                 }
1727         }
1728         return -1;
1729 }
1730
1731 static int ixj_sidac(IXJ *j, int val)
1732 {
1733         if(j->cardtype == QTI_PHONECARD){
1734                 if(j->flags.pcmciascp){
1735                         if(val == -1)
1736                                 return j->sidac.bits.txg;
1737
1738                         if(val < 0 || val > 0x1F)
1739                                 return -1;
1740
1741                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1742                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1743                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1744                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1745                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1746                         j->psccr.bits.dev = 0;
1747                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1748                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1749                         ixj_PCcontrol_wait(j);
1750                         return j->sidac.bits.txg;
1751                 }
1752         }
1753         return -1;
1754 }
1755
1756 static int ixj_pcmcia_cable_check(IXJ *j)
1757 {
1758         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1759         if (!j->flags.pcmciastate) {
1760                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1761                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1762                         j->flags.pcmciastate = 4;
1763                         return 0;
1764                 }
1765                 if (j->pccr1.bits.ed) {
1766                         j->pccr1.bits.ed = 0;
1767                         j->psccr.bits.dev = 3;
1768                         j->psccr.bits.rw = 1;
1769                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1770                         ixj_PCcontrol_wait(j);
1771                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1772                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1773                         j->psccr.bits.dev = 3;
1774                         j->psccr.bits.rw = 0;
1775                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1776                         ixj_PCcontrol_wait(j);
1777                         return j->pslic.bits.led2 ? 1 : 0;
1778                 } else if (j->flags.pcmciasct) {
1779                         return j->r_hook;
1780                 } else {
1781                         return 1;
1782                 }
1783         } else if (j->flags.pcmciastate == 4) {
1784                 if (!j->pccr1.bits.drf) {
1785                         j->flags.pcmciastate = 3;
1786                 }
1787                 return 0;
1788         } else if (j->flags.pcmciastate == 3) {
1789                 j->pccr2.bits.pwr = 0;
1790                 j->pccr2.bits.rstc = 1;
1791                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1792                 j->checkwait = jiffies + (hertz * 2);
1793                 j->flags.incheck = 1;
1794                 j->flags.pcmciastate = 2;
1795                 return 0;
1796         } else if (j->flags.pcmciastate == 2) {
1797                 if (j->flags.incheck) {
1798                         if (time_before(jiffies, j->checkwait)) {
1799                                 return 0;
1800                         } else {
1801                                 j->flags.incheck = 0;
1802                         }
1803                 }
1804                 j->pccr2.bits.pwr = 0;
1805                 j->pccr2.bits.rstc = 0;
1806                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1807                 j->flags.pcmciastate = 1;
1808                 return 0;
1809         } else if (j->flags.pcmciastate == 1) {
1810                 j->flags.pcmciastate = 0;
1811                 if (!j->pccr1.bits.drf) {
1812                         j->psccr.bits.dev = 3;
1813                         j->psccr.bits.rw = 1;
1814                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1815                         ixj_PCcontrol_wait(j);
1816                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1817
1818                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1819
1820                         if (j->flags.pcmciasct == 3) {
1821                                 j->flags.pcmciastate = 4;
1822                                 return 0;
1823                         } else if (j->flags.pcmciasct == 0) {
1824                                 j->pccr2.bits.pwr = 1;
1825                                 j->pccr2.bits.rstc = 0;
1826                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1827                                 j->port = PORT_SPEAKER;
1828                         } else {
1829                                 j->port = PORT_POTS;
1830                         }
1831                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1832                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1833                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1834                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1835                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1836                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1837                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1838                         j->psccr.bits.dev = 0;
1839                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1840                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1841                         ixj_PCcontrol_wait(j);
1842
1843                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1844                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1845                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1846                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1847                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1848                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1849                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1850                         j->psccr.bits.dev = 0;
1851                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1852                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1853                         ixj_PCcontrol_wait(j);
1854
1855                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1856                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1857                         j->psccr.bits.dev = 0;
1858                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1859                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1860                         ixj_PCcontrol_wait(j);
1861
1862                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1863                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1864                         j->psccr.bits.dev = 0;
1865                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1866                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1867                         ixj_PCcontrol_wait(j);
1868
1869                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1870                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1871                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1872                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1873                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1874                         j->sirxg.bits.iir = 1;                          /* IIR */
1875                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1876                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1877                         j->psccr.bits.dev = 0;
1878                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1879                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1880                         ixj_PCcontrol_wait(j);
1881
1882                         ixj_siadc(j, 0x17);
1883                         ixj_sidac(j, 0x1D);
1884
1885                         j->siaatt.bits.sot = 0;
1886                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1887                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1888                         j->psccr.bits.dev = 0;
1889                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1890                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1891                         ixj_PCcontrol_wait(j);
1892
1893                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1894                                 j->psccr.byte = j->pslic.byte = 0;
1895                                 j->pslic.bits.powerdown = 1;
1896                                 j->psccr.bits.dev = 3;
1897                                 j->psccr.bits.rw = 0;
1898                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1899                                 ixj_PCcontrol_wait(j);
1900                         }
1901                 }
1902                 return 0;
1903         } else {
1904                 j->flags.pcmciascp = 0;
1905                 return 0;
1906         }
1907         return 0;
1908 }
1909
1910 static int ixj_hookstate(IXJ *j)
1911 {
1912         int fOffHook = 0;
1913
1914         switch (j->cardtype) {
1915         case QTI_PHONEJACK:
1916                 ixj_gpio_read(j);
1917                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1918                 break;
1919         case QTI_LINEJACK:
1920         case QTI_PHONEJACK_LITE:
1921         case QTI_PHONEJACK_PCI:
1922                 SLIC_GetState(j);
1923                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1924                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1925                         if(fOffHook != j->p_hook) {
1926                                 if(!j->checkwait) {
1927                                         j->checkwait = jiffies;
1928                                 }
1929                                 if(time_before(jiffies, j->checkwait + 2)) {
1930                                         fOffHook ^= 1;
1931                                 } else {
1932                                         j->checkwait = 0;
1933                                 }
1934                                 j->p_hook = fOffHook;
1935                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1936                         }
1937                 } else {
1938                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1939                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1940                                 if (j->flags.ringing || j->flags.cringing) {
1941                                         if (!in_interrupt()) {
1942                                                 msleep(20);
1943                                         }
1944                                         SLIC_GetState(j);
1945                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1946                                                 ixj_ring_on(j);
1947                                         }
1948                                 }
1949                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1950                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1951                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1952                                 } else
1953                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1954                         }
1955                 }
1956                 break;
1957         case QTI_PHONECARD:
1958                 fOffHook = ixj_pcmcia_cable_check(j);
1959                 break;
1960         }
1961         if (j->r_hook != fOffHook) {
1962                 j->r_hook = fOffHook;
1963                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1964                         j->ex.bits.hookstate = 1;
1965                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1966                 } else if (!fOffHook) {
1967                         j->flash_end = jiffies + ((60 * hertz) / 100);
1968                 }
1969         }
1970         if (fOffHook) {
1971                 if(time_before(jiffies, j->flash_end)) {
1972                         j->ex.bits.flash = 1;
1973                         j->flash_end = 0;
1974                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1975                 }
1976         } else {
1977                 if(time_before(jiffies, j->flash_end)) {
1978                         fOffHook = 1;
1979                 }
1980         }
1981
1982         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1983                 fOffHook |= 2;
1984
1985         if (j->port == PORT_SPEAKER) {
1986                 if(j->cardtype == QTI_PHONECARD) {
1987                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1988                                 fOffHook |= 2;
1989                         }
1990                 } else {
1991                         fOffHook |= 2;
1992                 }
1993         }
1994
1995         if (j->port == PORT_HANDSET)
1996                 fOffHook |= 2;
1997
1998         return fOffHook;
1999 }
2000
2001 static void ixj_ring_off(IXJ *j)
2002 {
2003         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2004          {
2005                 if (ixjdebug & 0x0004)
2006                         printk(KERN_INFO "IXJ Ring Off\n");
2007                 j->gpio.bytes.high = 0x0B;
2008                 j->gpio.bytes.low = 0x00;
2009                 j->gpio.bits.gpio1 = 0;
2010                 j->gpio.bits.gpio2 = 1;
2011                 j->gpio.bits.gpio5 = 0;
2012                 ixj_WriteDSPCommand(j->gpio.word, j);
2013         } else                  /* Internet LineJACK */
2014         {
2015                 if (ixjdebug & 0x0004)
2016                         printk(KERN_INFO "IXJ Ring Off\n");
2017
2018                 if(!j->flags.cidplay)
2019                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2020
2021                 SLIC_GetState(j);
2022         }
2023 }
2024
2025 static void ixj_ring_start(IXJ *j)
2026 {
2027         j->flags.cringing = 1;
2028         if (ixjdebug & 0x0004)
2029                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2030         if (ixj_hookstate(j) & 1) {
2031                 if (j->port == PORT_POTS)
2032                         ixj_ring_off(j);
2033                 j->flags.cringing = 0;
2034                 if (ixjdebug & 0x0004)
2035                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2036         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2037                 j->ring_cadence_jif = jiffies;
2038                 j->flags.cidsent = j->flags.cidring = 0;
2039                 j->cadence_f[5].state = 0;
2040                 if(j->cadence_f[5].on1)
2041                         ixj_ring_on(j);
2042         } else {
2043                 j->ring_cadence_jif = jiffies;
2044                 j->ring_cadence_t = 15;
2045                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2046                         ixj_ring_on(j);
2047                 } else {
2048                         ixj_ring_off(j);
2049                 }
2050                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2051         }
2052 }
2053
2054 static int ixj_ring(IXJ *j)
2055 {
2056         char cntr;
2057         unsigned long jif;
2058
2059         j->flags.ringing = 1;
2060         if (ixj_hookstate(j) & 1) {
2061                 ixj_ring_off(j);
2062                 j->flags.ringing = 0;
2063                 return 1;
2064         }
2065         for (cntr = 0; cntr < j->maxrings; cntr++) {
2066                 jif = jiffies + (1 * hertz);
2067                 ixj_ring_on(j);
2068                 while (time_before(jiffies, jif)) {
2069                         if (ixj_hookstate(j) & 1) {
2070                                 ixj_ring_off(j);
2071                                 j->flags.ringing = 0;
2072                                 return 1;
2073                         }
2074                         set_current_state(TASK_INTERRUPTIBLE);
2075                         schedule_timeout(1);
2076                         if (signal_pending(current))
2077                                 break;
2078                 }
2079                 jif = jiffies + (3 * hertz);
2080                 ixj_ring_off(j);
2081                 while (time_before(jiffies, jif)) {
2082                         if (ixj_hookstate(j) & 1) {
2083                                 msleep(10);
2084                                 if (ixj_hookstate(j) & 1) {
2085                                         j->flags.ringing = 0;
2086                                         return 1;
2087                                 }
2088                         }
2089                         set_current_state(TASK_INTERRUPTIBLE);
2090                         schedule_timeout(1);
2091                         if (signal_pending(current))
2092                                 break;
2093                 }
2094         }
2095         ixj_ring_off(j);
2096         j->flags.ringing = 0;
2097         return 0;
2098 }
2099
2100 static int ixj_open(struct phone_device *p, struct file *file_p)
2101 {
2102         IXJ *j = get_ixj(p->board);
2103         file_p->private_data = j;
2104
2105         if (!j->DSPbase)
2106                 return -ENODEV;
2107
2108         if (file_p->f_mode & FMODE_READ) {
2109                 if(!j->readers) {
2110                         j->readers++;
2111                 } else {
2112                         return -EBUSY;
2113                 }
2114         }
2115
2116         if (file_p->f_mode & FMODE_WRITE) {
2117                 if(!j->writers) {
2118                         j->writers++;
2119                 } else {
2120                         if (file_p->f_mode & FMODE_READ){
2121                                 j->readers--;
2122                         }
2123                         return -EBUSY;
2124                 }
2125         }
2126
2127         if (j->cardtype == QTI_PHONECARD) {
2128                 j->pslic.bits.powerdown = 0;
2129                 j->psccr.bits.dev = 3;
2130                 j->psccr.bits.rw = 0;
2131                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2132                 ixj_PCcontrol_wait(j);
2133         }
2134
2135         j->flags.cidplay = 0;
2136         j->flags.cidcw_ack = 0;
2137
2138         if (ixjdebug & 0x0002)
2139                 printk(KERN_INFO "Opening board %d\n", p->board);
2140
2141         j->framesread = j->frameswritten = 0;
2142         return 0;
2143 }
2144
2145 static int ixj_release(struct inode *inode, struct file *file_p)
2146 {
2147         IXJ_TONE ti;
2148         int cnt;
2149         IXJ *j = file_p->private_data;
2150         int board = j->p.board;
2151
2152         /*
2153          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2154          *    This is necessary to keep the DSP from locking up.
2155          */
2156         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2157                 set_current_state(TASK_INTERRUPTIBLE);
2158                 schedule_timeout(1);
2159         }
2160         if (ixjdebug & 0x0002)
2161                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2162
2163         if (j->cardtype == QTI_PHONECARD)
2164                 ixj_set_port(j, PORT_SPEAKER);
2165         else
2166                 ixj_set_port(j, PORT_POTS);
2167
2168         aec_stop(j);
2169         ixj_play_stop(j);
2170         ixj_record_stop(j);
2171         set_play_volume(j, 0x100);
2172         set_rec_volume(j, 0x100);
2173         ixj_ring_off(j);
2174
2175         /* Restore the tone table to default settings. */
2176         ti.tone_index = 10;
2177         ti.gain0 = 1;
2178         ti.freq0 = hz941;
2179         ti.gain1 = 0;
2180         ti.freq1 = hz1209;
2181         ixj_init_tone(j, &ti);
2182         ti.tone_index = 11;
2183         ti.gain0 = 1;
2184         ti.freq0 = hz941;
2185         ti.gain1 = 0;
2186         ti.freq1 = hz1336;
2187         ixj_init_tone(j, &ti);
2188         ti.tone_index = 12;
2189         ti.gain0 = 1;
2190         ti.freq0 = hz941;
2191         ti.gain1 = 0;
2192         ti.freq1 = hz1477;
2193         ixj_init_tone(j, &ti);
2194         ti.tone_index = 13;
2195         ti.gain0 = 1;
2196         ti.freq0 = hz800;
2197         ti.gain1 = 0;
2198         ti.freq1 = 0;
2199         ixj_init_tone(j, &ti);
2200         ti.tone_index = 14;
2201         ti.gain0 = 1;
2202         ti.freq0 = hz1000;
2203         ti.gain1 = 0;
2204         ti.freq1 = 0;
2205         ixj_init_tone(j, &ti);
2206         ti.tone_index = 15;
2207         ti.gain0 = 1;
2208         ti.freq0 = hz1250;
2209         ti.gain1 = 0;
2210         ti.freq1 = 0;
2211         ixj_init_tone(j, &ti);
2212         ti.tone_index = 16;
2213         ti.gain0 = 1;
2214         ti.freq0 = hz950;
2215         ti.gain1 = 0;
2216         ti.freq1 = 0;
2217         ixj_init_tone(j, &ti);
2218         ti.tone_index = 17;
2219         ti.gain0 = 1;
2220         ti.freq0 = hz1100;
2221         ti.gain1 = 0;
2222         ti.freq1 = 0;
2223         ixj_init_tone(j, &ti);
2224         ti.tone_index = 18;
2225         ti.gain0 = 1;
2226         ti.freq0 = hz1400;
2227         ti.gain1 = 0;
2228         ti.freq1 = 0;
2229         ixj_init_tone(j, &ti);
2230         ti.tone_index = 19;
2231         ti.gain0 = 1;
2232         ti.freq0 = hz1500;
2233         ti.gain1 = 0;
2234         ti.freq1 = 0;
2235         ixj_init_tone(j, &ti);
2236         ti.tone_index = 20;
2237         ti.gain0 = 1;
2238         ti.freq0 = hz1600;
2239         ti.gain1 = 0;
2240         ti.freq1 = 0;
2241         ixj_init_tone(j, &ti);
2242         ti.tone_index = 21;
2243         ti.gain0 = 1;
2244         ti.freq0 = hz1800;
2245         ti.gain1 = 0;
2246         ti.freq1 = 0;
2247         ixj_init_tone(j, &ti);
2248         ti.tone_index = 22;
2249         ti.gain0 = 1;
2250         ti.freq0 = hz2100;
2251         ti.gain1 = 0;
2252         ti.freq1 = 0;
2253         ixj_init_tone(j, &ti);
2254         ti.tone_index = 23;
2255         ti.gain0 = 1;
2256         ti.freq0 = hz1300;
2257         ti.gain1 = 0;
2258         ti.freq1 = 0;
2259         ixj_init_tone(j, &ti);
2260         ti.tone_index = 24;
2261         ti.gain0 = 1;
2262         ti.freq0 = hz2450;
2263         ti.gain1 = 0;
2264         ti.freq1 = 0;
2265         ixj_init_tone(j, &ti);
2266         ti.tone_index = 25;
2267         ti.gain0 = 1;
2268         ti.freq0 = hz350;
2269         ti.gain1 = 0;
2270         ti.freq1 = hz440;
2271         ixj_init_tone(j, &ti);
2272         ti.tone_index = 26;
2273         ti.gain0 = 1;
2274         ti.freq0 = hz440;
2275         ti.gain1 = 0;
2276         ti.freq1 = hz480;
2277         ixj_init_tone(j, &ti);
2278         ti.tone_index = 27;
2279         ti.gain0 = 1;
2280         ti.freq0 = hz480;
2281         ti.gain1 = 0;
2282         ti.freq1 = hz620;
2283         ixj_init_tone(j, &ti);
2284
2285         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2286
2287         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2288
2289         j->ex.bits.dtmf_ready = 0;
2290         j->dtmf_state = 0;
2291         j->dtmf_wp = j->dtmf_rp = 0;
2292         j->rec_mode = j->play_mode = -1;
2293         j->flags.ringing = 0;
2294         j->maxrings = MAXRINGS;
2295         j->ring_cadence = USA_RING_CADENCE;
2296         if(j->cadence_f[5].enable) {
2297                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2298         }
2299         j->drybuffer = 0;
2300         j->winktime = 320;
2301         j->flags.dtmf_oob = 0;
2302         for (cnt = 0; cnt < 4; cnt++)
2303                 j->cadence_f[cnt].enable = 0;
2304
2305         idle(j);
2306
2307         if(j->cardtype == QTI_PHONECARD) {
2308                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2309         }
2310
2311         if (file_p->f_mode & FMODE_READ)
2312                 j->readers--;
2313         if (file_p->f_mode & FMODE_WRITE)
2314                 j->writers--;
2315
2316         if (j->read_buffer && !j->readers) {
2317                 kfree(j->read_buffer);
2318                 j->read_buffer = NULL;
2319                 j->read_buffer_size = 0;
2320         }
2321         if (j->write_buffer && !j->writers) {
2322                 kfree(j->write_buffer);
2323                 j->write_buffer = NULL;
2324                 j->write_buffer_size = 0;
2325         }
2326         j->rec_codec = j->play_codec = 0;
2327         j->rec_frame_size = j->play_frame_size = 0;
2328         j->flags.cidsent = j->flags.cidring = 0;
2329         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2330
2331         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2332                 ixj_set_port(j, PORT_PSTN);
2333                 daa_set_mode(j, SOP_PU_SLEEP);
2334                 ixj_set_pots(j, 1);
2335         }
2336         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2337
2338         /* Set up the default signals for events */
2339         for (cnt = 0; cnt < 35; cnt++)
2340                 j->ixj_signals[cnt] = SIGIO;
2341
2342         /* Set the excetion signal enable flags */
2343         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2344         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 =
2345         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;
2346
2347         file_p->private_data = NULL;
2348         clear_bit(board, &j->busyflags);
2349         return 0;
2350 }
2351
2352 static int read_filters(IXJ *j)
2353 {
2354         unsigned short fc, cnt, trg;
2355         int var;
2356
2357         trg = 0;
2358         if (ixj_WriteDSPCommand(0x5144, j)) {
2359                 if(ixjdebug & 0x0001) {
2360                         printk(KERN_INFO "Read Frame Counter failed!\n");
2361                 }
2362                 return -1;
2363         }
2364         fc = j->ssr.high << 8 | j->ssr.low;
2365         if (fc == j->frame_count)
2366                 return 1;
2367
2368         j->frame_count = fc;
2369
2370         if (j->dtmf_proc)
2371                 return 1;
2372
2373         var = 10;
2374
2375         for (cnt = 0; cnt < 4; cnt++) {
2376                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2377                         if(ixjdebug & 0x0001) {
2378                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2379                         }
2380                         return -1;
2381                 }
2382                 if (ixj_WriteDSPCommand(0x515C, j)) {
2383                         if(ixjdebug & 0x0001) {
2384                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2385                         }
2386                         return -1;
2387                 }
2388                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2389
2390                 if (j->cadence_f[cnt].enable) {
2391                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2392                                 if (j->cadence_f[cnt].state == 0) {
2393                                         j->cadence_f[cnt].state = 1;
2394                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2395                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2396                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2397                                 } else if (j->cadence_f[cnt].state == 2 &&
2398                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2399                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2400                                         if (j->cadence_f[cnt].on2) {
2401                                                 j->cadence_f[cnt].state = 3;
2402                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2403                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2404                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2405                                         } else {
2406                                                 j->cadence_f[cnt].state = 7;
2407                                         }
2408                                 } else if (j->cadence_f[cnt].state == 4 &&
2409                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2410                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2411                                         if (j->cadence_f[cnt].on3) {
2412                                                 j->cadence_f[cnt].state = 5;
2413                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2414                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2415                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2416                                         } else {
2417                                                 j->cadence_f[cnt].state = 7;
2418                                         }
2419                                 } else {
2420                                         j->cadence_f[cnt].state = 0;
2421                                 }
2422                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2423                                 if (j->cadence_f[cnt].state == 1) {
2424                                         if(!j->cadence_f[cnt].on1) {
2425                                                 j->cadence_f[cnt].state = 7;
2426                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2427                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2428                                                 if(j->cadence_f[cnt].off1) {
2429                                                         j->cadence_f[cnt].state = 2;
2430                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2431                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2432                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2433                                                 } else {
2434                                                         j->cadence_f[cnt].state = 7;
2435                                                 }
2436                                         } else {
2437                                                 j->cadence_f[cnt].state = 0;
2438                                         }
2439                                 } else if (j->cadence_f[cnt].state == 3) {
2440                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2441                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2442                                                 if(j->cadence_f[cnt].off2) {
2443                                                         j->cadence_f[cnt].state = 4;
2444                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2445                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2446                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2447                                                 } else {
2448                                                         j->cadence_f[cnt].state = 7;
2449                                                 }
2450                                         } else {
2451                                                 j->cadence_f[cnt].state = 0;
2452                                         }
2453                                 } else if (j->cadence_f[cnt].state == 5) {
2454                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2455                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2456                                                 if(j->cadence_f[cnt].off3) {
2457                                                         j->cadence_f[cnt].state = 6;
2458                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2459                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2460                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2461                                                 } else {
2462                                                         j->cadence_f[cnt].state = 7;
2463                                                 }
2464                                         } else {
2465                                                 j->cadence_f[cnt].state = 0;
2466                                         }
2467                                 } else {
2468                                         j->cadence_f[cnt].state = 0;
2469                                 }
2470                         } else {
2471                                 switch(j->cadence_f[cnt].state) {
2472                                         case 1:
2473                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2474                                                    !j->cadence_f[cnt].off1 &&
2475                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2476                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2477                                                         j->cadence_f[cnt].state = 7;
2478                                                 }
2479                                                 break;
2480                                         case 3:
2481                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2482                                                    !j->cadence_f[cnt].off2 &&
2483                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2484                                                         j->cadence_f[cnt].state = 7;
2485                                                 }
2486                                                 break;
2487                                         case 5:
2488                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2489                                                    !j->cadence_f[cnt].off3) {
2490                                                         j->cadence_f[cnt].state = 7;
2491                                                 }
2492                                                 break;
2493                                 }
2494                         }
2495
2496                         if (ixjdebug & 0x0040) {
2497                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2498                                 switch(j->cadence_f[cnt].state) {
2499                                         case 0:
2500                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2501                                                 break;
2502                                         case 1:
2503                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2504                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2505                                                 break;
2506                                         case 2:
2507                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2508                                                                                                                         j->cadence_f[cnt].off1max);
2509                                                 break;
2510                                         case 3:
2511                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2512                                                                                                                         j->cadence_f[cnt].on2max);
2513                                                 break;
2514                                         case 4:
2515                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2516                                                                                                                         j->cadence_f[cnt].off2max);
2517                                                 break;
2518                                         case 5:
2519                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2520                                                                                                                         j->cadence_f[cnt].on3max);
2521                                                 break;
2522                                         case 6:
2523                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2524                                                                                                                         j->cadence_f[cnt].off3max);
2525                                                 break;
2526                                 }
2527                         }
2528                 }
2529                 if (j->cadence_f[cnt].state == 7) {
2530                         j->cadence_f[cnt].state = 0;
2531                         if (j->cadence_f[cnt].enable == 1)
2532                                 j->cadence_f[cnt].enable = 0;
2533                         switch (cnt) {
2534                         case 0:
2535                                 if(ixjdebug & 0x0020) {
2536                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2537                                 }
2538                                 j->ex.bits.fc0 = 1;
2539                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2540                                 break;
2541                         case 1:
2542                                 if(ixjdebug & 0x0020) {
2543                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2544                                 }
2545                                 j->ex.bits.fc1 = 1;
2546                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2547                                 break;
2548                         case 2:
2549                                 if(ixjdebug & 0x0020) {
2550                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2551                                 }
2552                                 j->ex.bits.fc2 = 1;
2553                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2554                                 break;
2555                         case 3:
2556                                 if(ixjdebug & 0x0020) {
2557                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2558                                 }
2559                                 j->ex.bits.fc3 = 1;
2560                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2561                                 break;
2562                         }
2563                 }
2564                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2565                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2566                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2567                                 trg = 1;
2568                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2569                                 trg = 0;
2570                         }
2571                         switch (cnt) {
2572                         case 0:
2573                                 if(ixjdebug & 0x0020) {
2574                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2575                                 }
2576                                 j->ex.bits.f0 = 1;
2577                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2578                                 break;
2579                         case 1:
2580                                 if(ixjdebug & 0x0020) {
2581                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2582                                 }
2583                                 j->ex.bits.f1 = 1;
2584                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2585                                 break;
2586                         case 2:
2587                                 if(ixjdebug & 0x0020) {
2588                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2589                                 }
2590                                 j->ex.bits.f2 = 1;
2591                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2592                                 break;
2593                         case 3:
2594                                 if(ixjdebug & 0x0020) {
2595                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2596                                 }
2597                                 j->ex.bits.f3 = 1;
2598                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2599                                 break;
2600                         }
2601                 }
2602         }
2603         return 0;
2604 }
2605
2606 static int LineMonitor(IXJ *j)
2607 {
2608         if (j->dtmf_proc) {
2609                 return -1;
2610         }
2611         j->dtmf_proc = 1;
2612
2613         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2614                 return -1;
2615
2616         j->dtmf.bytes.high = j->ssr.high;
2617         j->dtmf.bytes.low = j->ssr.low;
2618         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2619                 j->dtmf_state = 1;
2620                 j->dtmf_current = j->dtmf.bits.digit;
2621         }
2622         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2623          {
2624                 if(!j->cidcw_wait) {
2625                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2626                         j->dtmf_wp++;
2627                         if (j->dtmf_wp == 79)
2628                                 j->dtmf_wp = 0;
2629                         j->ex.bits.dtmf_ready = 1;
2630                         if(j->ex_sig.bits.dtmf_ready) {
2631                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2632                         }
2633                 }
2634                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2635                         if(ixjdebug & 0x0020) {
2636                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2637                         }
2638                         j->flags.cidcw_ack = 1;
2639                 }
2640                 j->dtmf_state = 0;
2641         }
2642         j->dtmf_proc = 0;
2643
2644         return 0;
2645 }
2646
2647 /************************************************************************
2648 *
2649 * Functions to allow alaw <-> ulaw conversions.
2650 *
2651 ************************************************************************/
2652
2653 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2654 {
2655         static unsigned char table_ulaw2alaw[] =
2656         {
2657                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2658                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2659                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2660                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2661                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2662                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2663                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2664                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2665                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2666                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2667                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2668                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2669                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2670                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2671                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2672                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2673                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2674                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2675                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2676                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2677                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2678                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2679                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2680                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2681                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2682                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2683                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2684                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2685                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2686                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2687                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2688                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2689         };
2690
2691         while (len--)
2692         {
2693                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2694                 buff++;
2695         }
2696 }
2697
2698 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2699 {
2700         static unsigned char table_alaw2ulaw[] =
2701         {
2702                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2703                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2704                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2705                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2706                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2707                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2708                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2709                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2710                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2711                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2712                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2713                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2714                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2715                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2716                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2717                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2718                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2719                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2720                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2721                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2722                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2723                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2724                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2725                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2726                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2727                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2728                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2729                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2730                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2731                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2732                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2733                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2734         };
2735
2736         while (len--)
2737         {
2738                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2739                 buff++;
2740         }
2741 }
2742
2743 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2744 {
2745         unsigned long i = *ppos;
2746         IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2747
2748         DECLARE_WAITQUEUE(wait, current);
2749
2750         if (j->flags.inread)
2751                 return -EALREADY;
2752
2753         j->flags.inread = 1;
2754
2755         add_wait_queue(&j->read_q, &wait);
2756         set_current_state(TASK_INTERRUPTIBLE);
2757         mb();
2758
2759         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2760                 ++j->read_wait;
2761                 if (file_p->f_flags & O_NONBLOCK) {
2762                         set_current_state(TASK_RUNNING);
2763                         remove_wait_queue(&j->read_q, &wait);
2764                         j->flags.inread = 0;
2765                         return -EAGAIN;
2766                 }
2767                 if (!ixj_hookstate(j)) {
2768                         set_current_state(TASK_RUNNING);
2769                         remove_wait_queue(&j->read_q, &wait);
2770                         j->flags.inread = 0;
2771                         return 0;
2772                 }
2773                 interruptible_sleep_on(&j->read_q);
2774                 if (signal_pending(current)) {
2775                         set_current_state(TASK_RUNNING);
2776                         remove_wait_queue(&j->read_q, &wait);
2777                         j->flags.inread = 0;
2778                         return -EINTR;
2779                 }
2780         }
2781
2782         remove_wait_queue(&j->read_q, &wait);
2783         set_current_state(TASK_RUNNING);
2784         /* Don't ever copy more than the user asks */
2785         if(j->rec_codec == ALAW)
2786                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2787         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2788         j->read_buffer_ready = 0;
2789         if (i) {
2790                 j->flags.inread = 0;
2791                 return -EFAULT;
2792         } else {
2793                 j->flags.inread = 0;
2794                 return min(length, j->read_buffer_size);
2795         }
2796 }
2797
2798 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2799                           loff_t * ppos)
2800 {
2801         int pre_retval;
2802         ssize_t read_retval = 0;
2803         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2804
2805         pre_retval = ixj_PreRead(j, 0L);
2806         switch (pre_retval) {
2807         case NORMAL:
2808                 read_retval = ixj_read(file_p, buf, length, ppos);
2809                 ixj_PostRead(j, 0L);
2810                 break;
2811         case NOPOST:
2812                 read_retval = ixj_read(file_p, buf, length, ppos);
2813                 break;
2814         case POSTONLY:
2815                 ixj_PostRead(j, 0L);
2816                 break;
2817         default:
2818                 read_retval = pre_retval;
2819         }
2820         return read_retval;
2821 }
2822
2823 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2824 {
2825         unsigned long i = *ppos;
2826         IXJ *j = file_p->private_data;
2827
2828         DECLARE_WAITQUEUE(wait, current);
2829
2830         if (j->flags.inwrite)
2831                 return -EALREADY;
2832
2833         j->flags.inwrite = 1;
2834
2835         add_wait_queue(&j->write_q, &wait);
2836         set_current_state(TASK_INTERRUPTIBLE);
2837         mb();
2838
2839
2840         while (!j->write_buffers_empty) {
2841                 ++j->write_wait;
2842                 if (file_p->f_flags & O_NONBLOCK) {
2843                         set_current_state(TASK_RUNNING);
2844                         remove_wait_queue(&j->write_q, &wait);
2845                         j->flags.inwrite = 0;
2846                         return -EAGAIN;
2847                 }
2848                 if (!ixj_hookstate(j)) {
2849                         set_current_state(TASK_RUNNING);
2850                         remove_wait_queue(&j->write_q, &wait);
2851                         j->flags.inwrite = 0;
2852                         return 0;
2853                 }
2854                 interruptible_sleep_on(&j->write_q);
2855                 if (signal_pending(current)) {
2856                         set_current_state(TASK_RUNNING);
2857                         remove_wait_queue(&j->write_q, &wait);
2858                         j->flags.inwrite = 0;
2859                         return -EINTR;
2860                 }
2861         }
2862         set_current_state(TASK_RUNNING);
2863         remove_wait_queue(&j->write_q, &wait);
2864         if (j->write_buffer_wp + count >= j->write_buffer_end)
2865                 j->write_buffer_wp = j->write_buffer;
2866         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2867         if (i) {
2868                 j->flags.inwrite = 0;
2869                 return -EFAULT;
2870         }
2871        if(j->play_codec == ALAW)
2872                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2873         j->flags.inwrite = 0;
2874         return min(count, j->write_buffer_size);
2875 }
2876
2877 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2878 {
2879         int pre_retval;
2880         ssize_t write_retval = 0;
2881
2882         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2883
2884         pre_retval = ixj_PreWrite(j, 0L);
2885         switch (pre_retval) {
2886         case NORMAL:
2887                 write_retval = ixj_write(file_p, buf, count, ppos);
2888                 if (write_retval > 0) {
2889                         ixj_PostWrite(j, 0L);
2890                         j->write_buffer_wp += write_retval;
2891                         j->write_buffers_empty--;
2892                 }
2893                 break;
2894         case NOPOST:
2895                 write_retval = ixj_write(file_p, buf, count, ppos);
2896                 if (write_retval > 0) {
2897                         j->write_buffer_wp += write_retval;
2898                         j->write_buffers_empty--;
2899                 }
2900                 break;
2901         case POSTONLY:
2902                 ixj_PostWrite(j, 0L);
2903                 break;
2904         default:
2905                 write_retval = pre_retval;
2906         }
2907         return write_retval;
2908 }
2909
2910 static void ixj_read_frame(IXJ *j)
2911 {
2912         int cnt, dly;
2913
2914         if (j->read_buffer) {
2915                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2916                         if (!(cnt % 16) && !IsRxReady(j)) {
2917                                 dly = 0;
2918                                 while (!IsRxReady(j)) {
2919                                         if (dly++ > 5) {
2920                                                 dly = 0;
2921                                                 break;
2922                                         }
2923                                         udelay(10);
2924                                 }
2925                         }
2926                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2927                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2928                                 inb_p(j->DSPbase + 0x0E);
2929                                 inb_p(j->DSPbase + 0x0F);
2930                         }
2931                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2932                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2933                 }
2934                 ++j->framesread;
2935                 if (j->intercom != -1) {
2936                         if (IsTxReady(get_ixj(j->intercom))) {
2937                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2938                                         if (!(cnt % 16) && !IsTxReady(j)) {
2939                                                 dly = 0;
2940                                                 while (!IsTxReady(j)) {
2941                                                         if (dly++ > 5) {
2942                                                                 dly = 0;
2943                                                                 break;
2944                                                         }
2945                                                         udelay(10);
2946                                                 }
2947                                         }
2948                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2949                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2950                                 }
2951                                 get_ixj(j->intercom)->frameswritten++;
2952                         }
2953                 } else {
2954                         j->read_buffer_ready = 1;
2955                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2956
2957                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2958
2959                         if(j->ixj_signals[SIG_READ_READY])
2960                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2961                 }
2962         }
2963 }
2964
2965 static short fsk[][6][20] =
2966 {
2967         {
2968                 {
2969                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2970                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2971                 },
2972                 {
2973                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2974                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2975                 },
2976                 {
2977                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2978                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2979                 },
2980                 {
2981                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2982                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2983                 },
2984                 {
2985                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2986                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2987                 },
2988                 {
2989                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2990                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2991                 }
2992         },
2993         {
2994                 {
2995                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2996                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2997                 },
2998                 {
2999                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3000                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3001                 },
3002                 {
3003                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3004                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3005                 },
3006                 {
3007                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3008                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3009                 },
3010                 {
3011                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3012                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3013                 },
3014                 {
3015                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3016                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3017                 }
3018         }
3019 };
3020
3021
3022 static void ixj_write_cid_bit(IXJ *j, int bit)
3023 {
3024         while (j->fskcnt < 20) {
3025                 if(j->fskdcnt < (j->fsksize - 1))
3026                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3027
3028                 j->fskcnt += 3;
3029         }
3030         j->fskcnt %= 20;
3031
3032         if (!bit)
3033                 j->fskz++;
3034         if (j->fskz >= 6)
3035                 j->fskz = 0;
3036
3037 }
3038
3039 static void ixj_write_cid_byte(IXJ *j, char byte)
3040 {
3041         IXJ_CBYTE cb;
3042
3043                 cb.cbyte = byte;
3044                 ixj_write_cid_bit(j, 0);
3045                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3046                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3047                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3053                 ixj_write_cid_bit(j, 1);
3054 }
3055
3056 static void ixj_write_cid_seize(IXJ *j)
3057 {
3058         int cnt;
3059
3060         for (cnt = 0; cnt < 150; cnt++) {
3061                 ixj_write_cid_bit(j, 0);
3062                 ixj_write_cid_bit(j, 1);
3063         }
3064         for (cnt = 0; cnt < 180; cnt++) {
3065                 ixj_write_cid_bit(j, 1);
3066         }
3067 }
3068
3069 static void ixj_write_cidcw_seize(IXJ *j)
3070 {
3071         int cnt;
3072
3073         for (cnt = 0; cnt < 80; cnt++) {
3074                 ixj_write_cid_bit(j, 1);
3075         }
3076 }
3077
3078 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3079 {
3080         int cnt;
3081
3082         for (cnt = 0; cnt < strlen(s); cnt++) {
3083                 ixj_write_cid_byte(j, s[cnt]);
3084                 checksum = (checksum + s[cnt]);
3085         }
3086         return checksum;
3087 }
3088
3089 static void ixj_pad_fsk(IXJ *j, int pad)
3090 {
3091         int cnt;
3092
3093         for (cnt = 0; cnt < pad; cnt++) {
3094                 if(j->fskdcnt < (j->fsksize - 1))
3095                         j->fskdata[j->fskdcnt++] = 0x0000;
3096         }
3097         for (cnt = 0; cnt < 720; cnt++) {
3098                 if(j->fskdcnt < (j->fsksize - 1))
3099                         j->fskdata[j->fskdcnt++] = 0x0000;
3100         }
3101 }
3102
3103 static void ixj_pre_cid(IXJ *j)
3104 {
3105         j->cid_play_codec = j->play_codec;
3106         j->cid_play_frame_size = j->play_frame_size;
3107         j->cid_play_volume = get_play_volume(j);
3108         j->cid_play_flag = j->flags.playing;
3109
3110         j->cid_rec_codec = j->rec_codec;
3111         j->cid_rec_volume = get_rec_volume(j);
3112         j->cid_rec_flag = j->flags.recording;
3113
3114         j->cid_play_aec_level = j->aec_level;
3115
3116         switch(j->baseframe.low) {
3117                 case 0xA0:
3118                         j->cid_base_frame_size = 20;
3119                         break;
3120                 case 0x50:
3121                         j->cid_base_frame_size = 10;
3122                         break;
3123                 case 0xF0:
3124                         j->cid_base_frame_size = 30;
3125                         break;
3126         }
3127
3128         ixj_play_stop(j);
3129         ixj_cpt_stop(j);
3130
3131         j->flags.cidplay = 1;
3132
3133         set_base_frame(j, 30);
3134         set_play_codec(j, LINEAR16);
3135         set_play_volume(j, 0x1B);
3136         ixj_play_start(j);
3137 }
3138
3139 static void ixj_post_cid(IXJ *j)
3140 {
3141         ixj_play_stop(j);
3142
3143         if(j->cidsize > 5000) {
3144                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3145         }
3146         j->flags.cidplay = 0;
3147         if(ixjdebug & 0x0200) {
3148                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3149         }
3150
3151         ixj_fsk_free(j);
3152
3153         j->fskdcnt = 0;
3154         set_base_frame(j, j->cid_base_frame_size);
3155         set_play_codec(j, j->cid_play_codec);
3156         ixj_aec_start(j, j->cid_play_aec_level);
3157         set_play_volume(j, j->cid_play_volume);
3158
3159         set_rec_codec(j, j->cid_rec_codec);
3160         set_rec_volume(j, j->cid_rec_volume);
3161
3162         if(j->cid_rec_flag)
3163                 ixj_record_start(j);
3164
3165         if(j->cid_play_flag)
3166                 ixj_play_start(j);
3167
3168         if(j->cid_play_flag) {
3169                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3170         }
3171 }
3172
3173 static void ixj_write_cid(IXJ *j)
3174 {
3175         char sdmf1[50];
3176         char sdmf2[50];
3177         char sdmf3[80];
3178         char mdmflen, len1, len2, len3;
3179         int pad;
3180
3181         int checksum = 0;
3182
3183         if (j->dsp.low == 0x20 || j->flags.cidplay)
3184                 return;
3185
3186         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3187         j->cidsize = j->cidcnt = 0;
3188
3189         ixj_fsk_alloc(j);
3190
3191         strcpy(sdmf1, j->cid_send.month);
3192         strcat(sdmf1, j->cid_send.day);
3193         strcat(sdmf1, j->cid_send.hour);
3194         strcat(sdmf1, j->cid_send.min);
3195         strcpy(sdmf2, j->cid_send.number);
3196         strcpy(sdmf3, j->cid_send.name);
3197
3198         len1 = strlen(sdmf1);
3199         len2 = strlen(sdmf2);
3200         len3 = strlen(sdmf3);
3201         mdmflen = len1 + len2 + len3 + 6;
3202
3203         while(1){
3204                 ixj_write_cid_seize(j);
3205
3206                 ixj_write_cid_byte(j, 0x80);
3207                 checksum = 0x80;
3208                 ixj_write_cid_byte(j, mdmflen);
3209                 checksum = checksum + mdmflen;
3210
3211                 ixj_write_cid_byte(j, 0x01);
3212                 checksum = checksum + 0x01;
3213                 ixj_write_cid_byte(j, len1);
3214                 checksum = checksum + len1;
3215                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3216                 if(ixj_hookstate(j) & 1)
3217                         break;
3218
3219                 ixj_write_cid_byte(j, 0x02);
3220                 checksum = checksum + 0x02;
3221                 ixj_write_cid_byte(j, len2);
3222                 checksum = checksum + len2;
3223                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3224                 if(ixj_hookstate(j) & 1)
3225                         break;
3226
3227                 ixj_write_cid_byte(j, 0x07);
3228                 checksum = checksum + 0x07;
3229                 ixj_write_cid_byte(j, len3);
3230                 checksum = checksum + len3;
3231                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3232                 if(ixj_hookstate(j) & 1)
3233                         break;
3234
3235                 checksum %= 256;
3236                 checksum ^= 0xFF;
3237                 checksum += 1;
3238
3239                 ixj_write_cid_byte(j, (char) checksum);
3240
3241                 pad = j->fskdcnt % 240;
3242                 if (pad) {
3243                         pad = 240 - pad;
3244                 }
3245                 ixj_pad_fsk(j, pad);
3246                 break;
3247         }
3248
3249         ixj_write_frame(j);
3250 }
3251
3252 static void ixj_write_cidcw(IXJ *j)
3253 {
3254         IXJ_TONE ti;
3255
3256         char sdmf1[50];
3257         char sdmf2[50];
3258         char sdmf3[80];
3259         char mdmflen, len1, len2, len3;
3260         int pad;
3261
3262         int checksum = 0;
3263
3264         if (j->dsp.low == 0x20 || j->flags.cidplay)
3265                 return;
3266
3267         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3268         j->cidsize = j->cidcnt = 0;
3269
3270         ixj_fsk_alloc(j);
3271
3272         j->flags.cidcw_ack = 0;
3273
3274         ti.tone_index = 23;
3275         ti.gain0 = 1;
3276         ti.freq0 = hz440;
3277         ti.gain1 = 0;
3278         ti.freq1 = 0;
3279         ixj_init_tone(j, &ti);
3280
3281         ixj_set_tone_on(1500, j);
3282         ixj_set_tone_off(32, j);
3283         if(ixjdebug & 0x0200) {
3284                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3285         }
3286         ixj_play_tone(j, 23);
3287
3288         clear_bit(j->board, &j->busyflags);
3289         while(j->tone_state) {
3290                 set_current_state(TASK_INTERRUPTIBLE);
3291                 schedule_timeout(1);
3292         }
3293         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3294                 set_current_state(TASK_INTERRUPTIBLE);
3295                 schedule_timeout(1);
3296         }
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                 set_current_state(TASK_INTERRUPTIBLE);
3318                 schedule_timeout(1);
3319         }
3320         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3321                 set_current_state(TASK_INTERRUPTIBLE);
3322                 schedule_timeout(1);
3323         }
3324         if(ixjdebug & 0x0200) {
3325                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3326         }
3327
3328         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3329
3330         clear_bit(j->board, &j->busyflags);
3331         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3332                 set_current_state(TASK_INTERRUPTIBLE);
3333                 schedule_timeout(1);
3334         }
3335         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3336                 set_current_state(TASK_INTERRUPTIBLE);
3337                 schedule_timeout(1);
3338         }
3339         j->cidcw_wait = 0;
3340         if(!j->flags.cidcw_ack) {
3341                 if(ixjdebug & 0x0200) {
3342                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3343                 }
3344                 ixj_post_cid(j);
3345                 if(j->cid_play_flag) {
3346                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3347                 }
3348                 return;
3349         } else {
3350                 ixj_pre_cid(j);
3351         }
3352         j->flags.cidcw_ack = 0;
3353         strcpy(sdmf1, j->cid_send.month);
3354         strcat(sdmf1, j->cid_send.day);
3355         strcat(sdmf1, j->cid_send.hour);
3356         strcat(sdmf1, j->cid_send.min);
3357         strcpy(sdmf2, j->cid_send.number);
3358         strcpy(sdmf3, j->cid_send.name);
3359
3360         len1 = strlen(sdmf1);
3361         len2 = strlen(sdmf2);
3362         len3 = strlen(sdmf3);
3363         mdmflen = len1 + len2 + len3 + 6;
3364
3365         ixj_write_cidcw_seize(j);
3366
3367         ixj_write_cid_byte(j, 0x80);
3368         checksum = 0x80;
3369         ixj_write_cid_byte(j, mdmflen);
3370         checksum = checksum + mdmflen;
3371
3372         ixj_write_cid_byte(j, 0x01);
3373         checksum = checksum + 0x01;
3374         ixj_write_cid_byte(j, len1);
3375         checksum = checksum + len1;
3376         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3377
3378         ixj_write_cid_byte(j, 0x02);
3379         checksum = checksum + 0x02;
3380         ixj_write_cid_byte(j, len2);
3381         checksum = checksum + len2;
3382         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3383
3384         ixj_write_cid_byte(j, 0x07);
3385         checksum = checksum + 0x07;
3386         ixj_write_cid_byte(j, len3);
3387         checksum = checksum + len3;
3388         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3389
3390         checksum %= 256;
3391         checksum ^= 0xFF;
3392         checksum += 1;
3393
3394         ixj_write_cid_byte(j, (char) checksum);
3395
3396         pad = j->fskdcnt % 240;
3397         if (pad) {
3398                 pad = 240 - pad;
3399         }
3400         ixj_pad_fsk(j, pad);
3401         if(ixjdebug & 0x0200) {
3402                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3403         }
3404 }
3405
3406 static void ixj_write_vmwi(IXJ *j, int msg)
3407 {
3408         char mdmflen;
3409         int pad;
3410
3411         int checksum = 0;
3412
3413         if (j->dsp.low == 0x20 || j->flags.cidplay)
3414                 return;
3415
3416         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3417         j->cidsize = j->cidcnt = 0;
3418
3419         ixj_fsk_alloc(j);
3420
3421         mdmflen = 3;
3422
3423         if (j->port == PORT_POTS)
3424                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3425
3426         ixj_write_cid_seize(j);
3427
3428         ixj_write_cid_byte(j, 0x82);
3429         checksum = 0x82;
3430         ixj_write_cid_byte(j, mdmflen);
3431         checksum = checksum + mdmflen;
3432
3433         ixj_write_cid_byte(j, 0x0B);
3434         checksum = checksum + 0x0B;
3435         ixj_write_cid_byte(j, 1);
3436         checksum = checksum + 1;
3437
3438         if(msg) {
3439                 ixj_write_cid_byte(j, 0xFF);
3440                 checksum = checksum + 0xFF;
3441         }
3442         else {
3443                 ixj_write_cid_byte(j, 0x00);
3444                 checksum = checksum + 0x00;
3445         }
3446
3447         checksum %= 256;
3448         checksum ^= 0xFF;
3449         checksum += 1;
3450
3451         ixj_write_cid_byte(j, (char) checksum);
3452
3453         pad = j->fskdcnt % 240;
3454         if (pad) {
3455                 pad = 240 - pad;
3456         }
3457         ixj_pad_fsk(j, pad);
3458 }
3459
3460 static void ixj_write_frame(IXJ *j)
3461 {
3462         int cnt, frame_count, dly;
3463         IXJ_WORD dat;
3464         BYTES blankword;
3465
3466         frame_count = 0;
3467         if(j->flags.cidplay) {
3468                 for(cnt = 0; cnt < 480; cnt++) {
3469                         if (!(cnt % 16) && !IsTxReady(j)) {
3470                                 dly = 0;
3471                                 while (!IsTxReady(j)) {
3472                                         if (dly++ > 5) {
3473                                                 dly = 0;
3474                                                 break;
3475                                         }
3476                                         udelay(10);
3477                                 }
3478                         }
3479                         dat.word = j->fskdata[j->cidcnt++];
3480                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3481                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3482                         cnt++;
3483                 }
3484                 if(j->cidcnt >= j->fskdcnt) {
3485                         ixj_post_cid(j);
3486                 }
3487                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3488                    and there is real audio data in the buffer, we need to throw it away because
3489                    we just used it's time slot */
3490                 if (j->write_buffer_rp > j->write_buffer_wp) {
3491                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3492                         if (j->write_buffer_rp >= j->write_buffer_end) {
3493                                 j->write_buffer_rp = j->write_buffer;
3494                         }
3495                         j->write_buffers_empty++;
3496                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3497
3498                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3499                 }
3500         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3501                 if (j->write_buffer_wp > j->write_buffer_rp) {
3502                         frame_count =
3503                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3504                 }
3505                 if (j->write_buffer_rp > j->write_buffer_wp) {
3506                         frame_count =
3507                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3508                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3509                 }
3510                 if (frame_count >= 1) {
3511                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3512                                 switch (j->play_mode) {
3513                                 case PLAYBACK_MODE_ULAW:
3514                                 case PLAYBACK_MODE_ALAW:
3515                                         blankword.low = blankword.high = 0xFF;
3516                                         break;
3517                                 case PLAYBACK_MODE_8LINEAR:
3518                                 case PLAYBACK_MODE_16LINEAR:
3519                                         blankword.low = blankword.high = 0x00;
3520                                         break;
3521                                 case PLAYBACK_MODE_8LINEAR_WSS:
3522                                         blankword.low = blankword.high = 0x80;
3523                                         break;
3524                                 }
3525                                 for (cnt = 0; cnt < 16; cnt++) {
3526                                         if (!(cnt % 16) && !IsTxReady(j)) {
3527                                                 dly = 0;
3528                                                 while (!IsTxReady(j)) {
3529                                                         if (dly++ > 5) {
3530                                                                 dly = 0;
3531                                                                 break;
3532                                                         }
3533                                                         udelay(10);
3534                                                 }
3535                                         }
3536                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3537                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3538                                 }
3539                                 j->flags.play_first_frame = 0;
3540                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3541                                 for (cnt = 0; cnt < 24; cnt++) {
3542                                         if(cnt == 12) {
3543                                                 blankword.low = 0x02;
3544                                                 blankword.high = 0x00;
3545                                         }
3546                                         else {
3547                                                 blankword.low = blankword.high = 0x00;
3548                                         }
3549                                         if (!(cnt % 16) && !IsTxReady(j)) {
3550                                                 dly = 0;
3551                                                 while (!IsTxReady(j)) {
3552                                                         if (dly++ > 5) {
3553                                                                 dly = 0;
3554                                                                 break;
3555                                                         }
3556                                                         udelay(10);
3557                                                 }
3558                                         }
3559                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3560                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3561                                 }
3562                                 j->flags.play_first_frame = 0;
3563                         }
3564                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3565                                 if (!(cnt % 16) && !IsTxReady(j)) {
3566                                         dly = 0;
3567                                         while (!IsTxReady(j)) {
3568                                                 if (dly++ > 5) {
3569                                                         dly = 0;
3570                                                         break;
3571                                                 }
3572                                                 udelay(10);
3573                                         }
3574                                 }
3575                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3576                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3577                                         if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3578                                            j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3579                                            j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3580                                            j->write_buffer_rp + cnt + 9 == 0) {
3581                                         /* someone is trying to write silence lets make this a type 0 frame. */
3582                                                 outb_p(0x00, j->DSPbase + 0x0C);
3583                                                 outb_p(0x00, j->DSPbase + 0x0D);
3584                                         } else {
3585                                         /* so all other frames are type 1. */
3586                                                 outb_p(0x01, j->DSPbase + 0x0C);
3587                                                 outb_p(0x00, j->DSPbase + 0x0D);
3588                                         }
3589                                 }
3590                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592                                 *(j->write_buffer_rp + cnt) = 0;
3593                                 *(j->write_buffer_rp + cnt + 1) = 0;
3594                         }
3595                         j->write_buffer_rp += j->play_frame_size * 2;
3596                         if (j->write_buffer_rp >= j->write_buffer_end) {
3597                                 j->write_buffer_rp = j->write_buffer;
3598                         }
3599                         j->write_buffers_empty++;
3600                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3601
3602                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3603
3604                         ++j->frameswritten;
3605                 }
3606         } else {
3607                 j->drybuffer++;
3608         }
3609         if(j->ixj_signals[SIG_WRITE_READY]) {
3610                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611         }
3612 }
3613
3614 static int idle(IXJ *j)
3615 {
3616         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3617
3618                 return 0;
3619
3620         if (j->ssr.high || j->ssr.low) {
3621                 return 0;
3622         } else {
3623                 j->play_mode = -1;
3624                 j->flags.playing = 0;
3625                 j->rec_mode = -1;
3626                 j->flags.recording = 0;
3627                 return 1;
3628         }
3629 }
3630
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633         unsigned short cmd;
3634         int cnt;
3635
3636         idle(j);
3637         j->cid_play_aec_level = j->aec_level;
3638         aec_stop(j);
3639         for (cnt = 0; cnt < 10; cnt++) {
3640                 if (idle(j))
3641                         break;
3642         }
3643         if (j->ssr.high || j->ssr.low)
3644                 return -1;
3645         if (j->dsp.low != 0x20) {
3646                 switch (size) {
3647                 case 30:
3648                         cmd = 0x07F0;
3649                         /* Set Base Frame Size to 240 pg9-10 8021 */
3650                         break;
3651                 case 20:
3652                         cmd = 0x07A0;
3653                         /* Set Base Frame Size to 160 pg9-10 8021 */
3654                         break;
3655                 case 10:
3656                         cmd = 0x0750;
3657                         /* Set Base Frame Size to 80 pg9-10 8021 */
3658                         break;
3659                 default:
3660                         return -1;
3661                 }
3662         } else {
3663                 if (size == 30)
3664                         return size;
3665                 else
3666                         return -1;
3667         }
3668         if (ixj_WriteDSPCommand(cmd, j)) {
3669                 j->baseframe.high = j->baseframe.low = 0xFF;
3670                 return -1;
3671         } else {
3672                 j->baseframe.high = j->ssr.high;
3673                 j->baseframe.low = j->ssr.low;
3674                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676                         return -1;
3677                 }
3678         }
3679         ixj_aec_start(j, j->cid_play_aec_level);
3680         return size;
3681 }
3682
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685         int retval = 0;
3686
3687         j->rec_codec = rate;
3688
3689         switch (rate) {
3690         case G723_63:
3691                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692                         j->rec_frame_size = 12;
3693                         j->rec_mode = 0;
3694                 } else {
3695                         retval = 1;
3696                 }
3697                 break;
3698         case G723_53:
3699                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700                         j->rec_frame_size = 10;
3701                         j->rec_mode = 0;
3702                 } else {
3703                         retval = 1;
3704                 }
3705                 break;
3706         case TS85:
3707                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708                         j->rec_frame_size = 16;
3709                         j->rec_mode = 0;
3710                 } else {
3711                         retval = 1;
3712                 }
3713                 break;
3714         case TS48:
3715                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716                         j->rec_frame_size = 9;
3717                         j->rec_mode = 0;
3718                 } else {
3719                         retval = 1;
3720                 }
3721                 break;
3722         case TS41:
3723                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724                         j->rec_frame_size = 8;
3725                         j->rec_mode = 0;
3726                 } else {
3727                         retval = 1;
3728                 }
3729                 break;
3730         case G728:
3731                 if (j->dsp.low != 0x20) {
3732                         j->rec_frame_size = 48;
3733                         j->rec_mode = 0;
3734                 } else {
3735                         retval = 1;
3736                 }
3737                 break;
3738         case G729:
3739                 if (j->dsp.low != 0x20) {
3740                         if (!j->flags.g729_loaded) {
3741                                 retval = 1;
3742                                 break;
3743                         }
3744                         switch (j->baseframe.low) {
3745                         case 0xA0:
3746                                 j->rec_frame_size = 10;
3747                                 break;
3748                         case 0x50:
3749                                 j->rec_frame_size = 5;
3750                                 break;
3751                         default:
3752                                 j->rec_frame_size = 15;
3753                                 break;
3754                         }
3755                         j->rec_mode = 0;
3756                 } else {
3757                         retval = 1;
3758                 }
3759                 break;
3760         case G729B:
3761                 if (j->dsp.low != 0x20) {
3762                         if (!j->flags.g729_loaded) {
3763                                 retval = 1;
3764                                 break;
3765                         }
3766                         switch (j->baseframe.low) {
3767                         case 0xA0:
3768                                 j->rec_frame_size = 12;
3769                                 break;
3770                         case 0x50:
3771                                 j->rec_frame_size = 6;
3772                                 break;
3773                         default:
3774                                 j->rec_frame_size = 18;
3775                                 break;
3776                         }
3777                         j->rec_mode = 0;
3778                 } else {
3779                         retval = 1;
3780                 }
3781                 break;
3782         case ULAW:
3783                 switch (j->baseframe.low) {
3784                 case 0xA0:
3785                         j->rec_frame_size = 80;
3786                         break;
3787                 case 0x50:
3788                         j->rec_frame_size = 40;
3789                         break;
3790                 default:
3791                         j->rec_frame_size = 120;
3792                         break;
3793                 }
3794                 j->rec_mode = 4;
3795                 break;
3796         case ALAW:
3797                 switch (j->baseframe.low) {
3798                 case 0xA0:
3799                         j->rec_frame_size = 80;
3800                         break;
3801                 case 0x50:
3802                         j->rec_frame_size = 40;
3803                         break;
3804                 default:
3805                         j->rec_frame_size = 120;
3806                         break;
3807                 }
3808                 j->rec_mode = 4;
3809                 break;
3810         case LINEAR16:
3811                 switch (j->baseframe.low) {
3812                 case 0xA0:
3813                         j->rec_frame_size = 160;
3814                         break;
3815                 case 0x50:
3816                         j->rec_frame_size = 80;
3817                         break;
3818                 default:
3819                         j->rec_frame_size = 240;
3820                         break;
3821                 }
3822                 j->rec_mode = 5;
3823                 break;
3824         case LINEAR8:
3825                 switch (j->baseframe.low) {
3826                 case 0xA0:
3827                         j->rec_frame_size = 80;
3828                         break;
3829                 case 0x50:
3830                         j->rec_frame_size = 40;
3831                         break;
3832                 default:
3833                         j->rec_frame_size = 120;
3834                         break;
3835                 }
3836                 j->rec_mode = 6;
3837                 break;
3838         case WSS:
3839                 switch (j->baseframe.low) {
3840                 case 0xA0:
3841                         j->rec_frame_size = 80;
3842                         break;
3843                 case 0x50:
3844                         j->rec_frame_size = 40;
3845                         break;
3846                 default:
3847                         j->rec_frame_size = 120;
3848                         break;
3849                 }
3850                 j->rec_mode = 7;
3851                 break;
3852         default:
3853                 kfree(j->read_buffer);
3854                 j->rec_frame_size = 0;
3855                 j->rec_mode = -1;
3856                 j->read_buffer = NULL;
3857                 j->read_buffer_size = 0;
3858                 retval = 1;
3859                 break;
3860         }
3861         return retval;
3862 }
3863
3864 static int ixj_record_start(IXJ *j)
3865 {
3866         unsigned short cmd = 0x0000;
3867
3868         if (j->read_buffer) {
3869                 ixj_record_stop(j);
3870         }
3871         j->flags.recording = 1;
3872         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874         if(ixjdebug & 0x0002)
3875                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877         if (!j->rec_mode) {
3878                 switch (j->rec_codec) {
3879                 case G723_63:
3880                         cmd = 0x5131;
3881                         break;
3882                 case G723_53:
3883                         cmd = 0x5132;
3884                         break;
3885                 case TS85:
3886                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3887
3888                         break;
3889                 case TS48:
3890                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3891
3892                         break;
3893                 case TS41:
3894                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3895
3896                         break;
3897                 case G728:
3898                         cmd = 0x5135;
3899                         break;
3900                 case G729:
3901                 case G729B:
3902                         cmd = 0x5136;
3903                         break;
3904                 default:
3905                         return 1;
3906                 }
3907                 if (ixj_WriteDSPCommand(cmd, j))
3908                         return -1;
3909         }
3910         if (!j->read_buffer) {
3911                 if (!j->read_buffer)
3912                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913                 if (!j->read_buffer) {
3914                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915                         return -ENOMEM;
3916                 }
3917         }
3918         j->read_buffer_size = j->rec_frame_size * 2;
3919
3920         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3921
3922                 return -1;
3923
3924         switch (j->rec_mode) {
3925         case 0:
3926                 cmd = 0x1C03;   /* Record C1 */
3927
3928                 break;
3929         case 4:
3930                 if (j->ver.low == 0x12) {
3931                         cmd = 0x1E03;   /* Record C1 */
3932
3933                 } else {
3934                         cmd = 0x1E01;   /* Record C1 */
3935
3936                 }
3937                 break;
3938         case 5:
3939                 if (j->ver.low == 0x12) {
3940                         cmd = 0x1E83;   /* Record C1 */
3941
3942                 } else {
3943                         cmd = 0x1E81;   /* Record C1 */
3944
3945                 }
3946                 break;
3947         case 6:
3948                 if (j->ver.low == 0x12) {
3949                         cmd = 0x1F03;   /* Record C1 */
3950
3951                 } else {
3952                         cmd = 0x1F01;   /* Record C1 */
3953
3954                 }
3955                 break;
3956         case 7:
3957                 if (j->ver.low == 0x12) {
3958                         cmd = 0x1F83;   /* Record C1 */
3959                 } else {
3960                         cmd = 0x1F81;   /* Record C1 */
3961                 }
3962                 break;
3963         }
3964         if (ixj_WriteDSPCommand(cmd, j))
3965                 return -1;
3966
3967         if (j->flags.playing) {
3968                 ixj_aec_start(j, j->aec_level);
3969         }
3970         return 0;
3971 }
3972
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975         if (ixjdebug & 0x0002)
3976                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978         kfree(j->read_buffer);
3979         j->read_buffer = NULL;
3980         j->read_buffer_size = 0;
3981         if (j->rec_mode > -1) {
3982                 ixj_WriteDSPCommand(0x5120, j);
3983                 j->rec_mode = -1;
3984         }
3985         j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989         if (arg)
3990                 ixj_WriteDSPCommand(0x513F, j);
3991         else
3992                 ixj_WriteDSPCommand(0x513E, j);
3993 }
3994
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997         if (depth > 60)
3998                 depth = 60;
3999         if (depth < 0)
4000                 depth = 0;
4001         ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006         ixj_WriteDSPCommand(0xCF07, j);
4007         ixj_WriteDSPCommand(volume, j);
4008 }
4009
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012         ixj_WriteDSPCommand(0xCF05, j);
4013         return j->ssr.high << 8 | j->ssr.low;
4014 }
4015
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018         if(j->aec_level == AEC_AGC) {
4019                 if (ixjdebug & 0x0002)
4020                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021                 ixj_WriteDSPCommand(0xCF96, j);
4022                 ixj_WriteDSPCommand(volume, j);
4023         } else {
4024                 if (ixjdebug & 0x0002)
4025                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026                 ixj_WriteDSPCommand(0xCF03, j);
4027                 ixj_WriteDSPCommand(volume, j);
4028         }
4029 }
4030
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033         int newvolume, dsprecmax;
4034
4035         if (ixjdebug & 0x0002)
4036                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037         if(volume > 100 || volume < 0) {
4038           return -1;
4039         }
4040
4041         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042         switch (j->cardtype) {
4043         case QTI_PHONEJACK:
4044                 dsprecmax = 0x440;
4045                 break;
4046         case QTI_LINEJACK:
4047                 dsprecmax = 0x180;
4048                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4049                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4050                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4051                 break;
4052         case QTI_PHONEJACK_LITE:
4053                 dsprecmax = 0x4C0;
4054                 break;
4055         case QTI_PHONEJACK_PCI:
4056                 dsprecmax = 0x100;
4057                 break;
4058         case QTI_PHONECARD:
4059                 dsprecmax = 0x400;
4060                 break;
4061         default:
4062                 return -1;
4063         }
4064         newvolume = (dsprecmax * volume) / 100;
4065         set_rec_volume(j, newvolume);
4066         return 0;
4067 }
4068
4069 static int get_rec_volume(IXJ *j)
4070 {
4071         if(j->aec_level == AEC_AGC) {
4072                 if (ixjdebug & 0x0002)
4073                         printk(KERN_INFO "Getting AGC Threshold\n");
4074                 ixj_WriteDSPCommand(0xCF86, j);
4075                 if (ixjdebug & 0x0002)
4076                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077                 return j->ssr.high << 8 | j->ssr.low;
4078         } else {
4079                 if (ixjdebug & 0x0002)
4080                         printk(KERN_INFO "Getting Record Volume\n");
4081                 ixj_WriteDSPCommand(0xCF01, j);
4082                 return j->ssr.high << 8 | j->ssr.low;
4083         }
4084 }
4085
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088         int volume, newvolume, dsprecmax;
4089
4090         switch (j->cardtype) {
4091         case QTI_PHONEJACK:
4092                 dsprecmax = 0x440;
4093                 break;
4094         case QTI_LINEJACK:
4095                 dsprecmax = 0x180;
4096                 break;
4097         case QTI_PHONEJACK_LITE:
4098                 dsprecmax = 0x4C0;
4099                 break;
4100         case QTI_PHONEJACK_PCI:
4101                 dsprecmax = 0x100;
4102                 break;
4103         case QTI_PHONECARD:
4104                 dsprecmax = 0x400;
4105                 break;
4106         default:
4107                 return -1;
4108         }
4109         volume = get_rec_volume(j);
4110         newvolume = (volume * 100) / dsprecmax;
4111         if(newvolume > 100)
4112                 newvolume = 100;
4113         return newvolume;
4114 }
4115
4116 static int get_rec_level(IXJ *j)
4117 {
4118         int retval;
4119
4120         ixj_WriteDSPCommand(0xCF88, j);
4121
4122         retval = j->ssr.high << 8 | j->ssr.low;
4123         retval = (retval * 256) / 240;
4124         return retval;
4125 }
4126
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129         j->aec_level = level;
4130         if (ixjdebug & 0x0002)
4131                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132         if (!level) {
4133                 aec_stop(j);
4134         } else {
4135                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138                         ixj_WriteDSPCommand(0x0300, j);
4139                 }
4140                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144                 switch (level) {
4145                 case AEC_LOW:
4146                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148                         ixj_WriteDSPCommand(0xE011, j);
4149                         ixj_WriteDSPCommand(0xFFFF, j);
4150
4151                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4153
4154                         break;
4155
4156                 case AEC_MED:
4157                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159                         ixj_WriteDSPCommand(0xE011, j);
4160                         ixj_WriteDSPCommand(0x0080, j);
4161
4162                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4164
4165                         break;
4166
4167                 case AEC_HIGH:
4168                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170                         ixj_WriteDSPCommand(0xE011, j);
4171                         ixj_WriteDSPCommand(0x0080, j);
4172
4173                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4175
4176                         break;
4177
4178                 case AEC_AGC:
4179                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182                         ixj_WriteDSPCommand(0xE011, j);
4183                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188                                 ixj_WriteDSPCommand(0x0224, j);
4189                         else
4190                                 ixj_WriteDSPCommand(0x1224, j);
4191
4192                         ixj_WriteDSPCommand(0xE014, j);
4193                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4194
4195                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197                         /* Now we can set the AGC initial parameters and turn it on */
4198                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4199                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222                         break;
4223
4224                 case AEC_AUTO:
4225                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227                         ixj_WriteDSPCommand(0xE011, j);
4228                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233                                 ixj_WriteDSPCommand(0x0224, j);
4234                         else
4235                                 ixj_WriteDSPCommand(0x1224, j);
4236
4237                         ixj_WriteDSPCommand(0xE014, j);
4238                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4239
4240                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242                         break;
4243                 }
4244         }
4245 }
4246
4247 static void aec_stop(IXJ *j)
4248 {
4249         j->aec_level = AEC_OFF;
4250         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253                 ixj_WriteDSPCommand(0x0700, j);
4254         }
4255         if (j->play_mode != -1 && j->rec_mode != -1)
4256         {
4257                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258         }
4259 }
4260
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263         int retval = 0;
4264
4265         j->play_codec = rate;
4266
4267         switch (rate) {
4268         case G723_63:
4269                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270                         j->play_frame_size = 12;
4271                         j->play_mode = 0;
4272                 } else {
4273                         retval = 1;
4274                 }
4275                 break;
4276         case G723_53:
4277                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278                         j->play_frame_size = 10;
4279                         j->play_mode = 0;
4280                 } else {
4281                         retval = 1;
4282                 }
4283                 break;
4284         case TS85:
4285                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286                         j->play_frame_size = 16;
4287                         j->play_mode = 0;
4288                 } else {
4289                         retval = 1;
4290                 }
4291                 break;
4292         case TS48:
4293                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294                         j->play_frame_size = 9;
4295                         j->play_mode = 0;
4296                 } else {
4297                         retval = 1;
4298                 }
4299                 break;
4300         case TS41:
4301                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302                         j->play_frame_size = 8;
4303                         j->play_mode = 0;
4304                 } else {
4305                         retval = 1;
4306                 }
4307                 break;
4308         case G728:
4309                 if (j->dsp.low != 0x20) {
4310                         j->play_frame_size = 48;
4311                         j->play_mode = 0;
4312                 } else {
4313                         retval = 1;
4314                 }
4315                 break;
4316         case G729:
4317                 if (j->dsp.low != 0x20) {
4318                         if (!j->flags.g729_loaded) {
4319                                 retval = 1;
4320                                 break;
4321                         }
4322                         switch (j->baseframe.low) {
4323                         case 0xA0:
4324                                 j->play_frame_size = 10;
4325                                 break;
4326                         case 0x50:
4327                                 j->play_frame_size = 5;
4328                                 break;
4329                         default:
4330                                 j->play_frame_size = 15;
4331                                 break;
4332                         }
4333                         j->play_mode = 0;
4334                 } else {
4335                         retval = 1;
4336                 }
4337                 break;
4338         case G729B:
4339                 if (j->dsp.low != 0x20) {
4340                         if (!j->flags.g729_loaded) {
4341                                 retval = 1;
4342                                 break;
4343                         }
4344                         switch (j->baseframe.low) {
4345                         case 0xA0:
4346                                 j->play_frame_size = 12;
4347                                 break;
4348                         case 0x50:
4349                                 j->play_frame_size = 6;
4350                                 break;
4351                         default:
4352                                 j->play_frame_size = 18;
4353                                 break;
4354                         }
4355                         j->play_mode = 0;
4356                 } else {
4357                         retval = 1;
4358                 }
4359                 break;
4360         case ULAW:
4361                 switch (j->baseframe.low) {
4362                 case 0xA0:
4363                         j->play_frame_size = 80;
4364                         break;
4365                 case 0x50:
4366                         j->play_frame_size = 40;
4367                         break;
4368                 default:
4369                         j->play_frame_size = 120;
4370                         break;
4371                 }
4372                 j->play_mode = 2;
4373                 break;
4374         case ALAW:
4375                 switch (j->baseframe.low) {
4376                 case 0xA0:
4377                         j->play_frame_size = 80;
4378                         break;
4379                 case 0x50:
4380                         j->play_frame_size = 40;
4381                         break;
4382                 default:
4383                         j->play_frame_size = 120;
4384                         break;
4385                 }
4386                 j->play_mode = 2;
4387                 break;
4388         case LINEAR16:
4389                 switch (j->baseframe.low) {
4390                 case 0xA0:
4391                         j->play_frame_size = 160;
4392                         break;
4393                 case 0x50:
4394                         j->play_frame_size = 80;
4395                         break;
4396                 default:
4397                         j->play_frame_size = 240;
4398                         break;
4399                 }
4400                 j->play_mode = 6;
4401                 break;
4402         case LINEAR8:
4403                 switch (j->baseframe.low) {
4404                 case 0xA0:
4405                         j->play_frame_size = 80;
4406                         break;
4407                 case 0x50:
4408                         j->play_frame_size = 40;
4409                         break;
4410                 default:
4411                         j->play_frame_size = 120;
4412                         break;
4413                 }
4414                 j->play_mode = 4;
4415                 break;
4416         case WSS:
4417                 switch (j->baseframe.low) {
4418                 case 0xA0:
4419                         j->play_frame_size = 80;
4420                         break;
4421                 case 0x50:
4422                         j->play_frame_size = 40;
4423                         break;
4424                 default:
4425                         j->play_frame_size = 120;
4426                         break;
4427                 }
4428                 j->play_mode = 5;
4429                 break;
4430         default:
4431                 kfree(j->write_buffer);
4432                 j->play_frame_size = 0;
4433                 j->play_mode = -1;
4434                 j->write_buffer = NULL;
4435                 j->write_buffer_size = 0;
4436                 retval = 1;
4437                 break;
4438         }
4439         return retval;
4440 }
4441
4442 static int ixj_play_start(IXJ *j)
4443 {
4444         unsigned short cmd = 0x0000;
4445
4446         if (j->write_buffer) {
4447                 ixj_play_stop(j);
4448         }
4449
4450         if(ixjdebug & 0x0002)
4451                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453         j->flags.playing = 1;
4454         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456         j->flags.play_first_frame = 1;
4457         j->drybuffer = 0;
4458
4459         if (!j->play_mode) {
4460                 switch (j->play_codec) {
4461                 case G723_63:
4462                         cmd = 0x5231;
4463                         break;
4464                 case G723_53:
4465                         cmd = 0x5232;
4466                         break;
4467                 case TS85:
4468                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4469
4470                         break;
4471                 case TS48:
4472                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4473
4474                         break;
4475                 case TS41:
4476                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4477
4478                         break;
4479                 case G728:
4480                         cmd = 0x5235;
4481                         break;
4482                 case G729:
4483                 case G729B:
4484                         cmd = 0x5236;
4485                         break;
4486                 default:
4487                         return 1;
4488                 }
4489                 if (ixj_WriteDSPCommand(cmd, j))
4490                         return -1;
4491         }
4492         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493         if (!j->write_buffer) {
4494                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495                 return -ENOMEM;
4496         }
4497 /*      j->write_buffers_empty = 2; */
4498         j->write_buffers_empty = 1;
4499         j->write_buffer_size = j->play_frame_size * 2;
4500         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4504
4505                 return -1;
4506
4507         switch (j->play_mode) {
4508         case 0:
4509                 cmd = 0x2C03;
4510                 break;
4511         case 2:
4512                 if (j->ver.low == 0x12) {
4513                         cmd = 0x2C23;
4514                 } else {
4515                         cmd = 0x2C21;
4516                 }
4517                 break;
4518         case 4:
4519                 if (j->ver.low == 0x12) {
4520                         cmd = 0x2C43;
4521                 } else {
4522                         cmd = 0x2C41;
4523                 }
4524                 break;
4525         case 5:
4526                 if (j->ver.low == 0x12) {
4527                         cmd = 0x2C53;
4528                 } else {
4529                         cmd = 0x2C51;
4530                 }
4531                 break;
4532         case 6:
4533                 if (j->ver.low == 0x12) {
4534                         cmd = 0x2C63;
4535                 } else {
4536                         cmd = 0x2C61;
4537                 }
4538                 break;
4539         }
4540         if (ixj_WriteDSPCommand(cmd, j))
4541                 return -1;
4542
4543         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4544                 return -1;
4545
4546         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4547                 return -1;
4548
4549         if (j->flags.recording) {
4550                 ixj_aec_start(j, j->aec_level);
4551         }
4552
4553         return 0;
4554 }
4555
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558         if (ixjdebug & 0x0002)
4559                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561         kfree(j->write_buffer);
4562         j->write_buffer = NULL;
4563         j->write_buffer_size = 0;
4564         if (j->play_mode > -1) {
4565                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4566
4567                 j->play_mode = -1;
4568         }
4569         j->flags.playing = 0;
4570 }
4571
4572 static inline int get_play_level(IXJ *j)
4573 {
4574         int retval;
4575
4576         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577         return j->ssr.high << 8 | j->ssr.low;
4578         retval = j->ssr.high << 8 | j->ssr.low;
4579         retval = (retval * 256) / 240;
4580         return retval;
4581 }
4582
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585         unsigned int mask = 0;
4586
4587         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4588
4589         poll_wait(file_p, &(j->poll_q), wait);
4590         if (j->read_buffer_ready > 0)
4591                 mask |= POLLIN | POLLRDNORM;    /* readable */
4592         if (j->write_buffers_empty > 0)
4593                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4594         if (j->ex.bytes)
4595                 mask |= POLLPRI;
4596         return mask;
4597 }
4598
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601         if (!j->tone_state) {
4602                 if(ixjdebug & 0x0002) {
4603                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604                 }
4605                 if (j->dsp.low == 0x20) {
4606                         idle(j);
4607                 }
4608                 j->tone_start_jif = jiffies;
4609
4610                 j->tone_state = 1;
4611         }
4612
4613         j->tone_index = tone;
4614         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615                 return -1;
4616
4617         return 0;
4618 }
4619
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622         j->tone_on_time = arg;
4623
4624         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4625
4626                 return -1;
4627
4628         if (ixj_WriteDSPCommand(arg, j))
4629                 return -1;
4630
4631         return 0;
4632 }
4633
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636         int cnt;
4637
4638         j->pld_scrr.byte = inb_p(j->XILINXbase);
4639         if (!j->pld_scrr.bits.sci) {
4640                 for (cnt = 0; cnt < 10; cnt++) {
4641                         udelay(32);
4642                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644                         if ((j->pld_scrr.bits.sci))
4645                                 return 1;
4646                 }
4647                 if (ixjdebug & 0x0001)
4648                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649                 return 0;
4650         } else
4651                 return 1;
4652 }
4653
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656         int cnt;
4657
4658         j->pld_scrr.byte = inb_p(j->XILINXbase);
4659         if (j->pld_scrr.bits.sci) {
4660                 for (cnt = 0; cnt < 10; cnt++) {
4661                         udelay(32);
4662                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664                         if (!(j->pld_scrr.bits.sci))
4665                                 return 1;
4666                 }
4667                 if (ixjdebug & 0x0001)
4668                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669                 return 0;
4670         } else
4671                 return 1;
4672 }
4673
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676         switch (control) {
4677         case SCI_End:
4678                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4679
4680                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4681
4682                 break;
4683         case SCI_Enable_DAA:
4684                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4685
4686                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4687
4688                 break;
4689         case SCI_Enable_Mixer:
4690                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4691
4692                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4693
4694                 break;
4695         case SCI_Enable_EEPROM:
4696                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4697
4698                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4699
4700                 break;
4701         default:
4702                 return 0;
4703                 break;
4704         }
4705         outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707         switch (control) {
4708         case SCI_End:
4709                 return 1;
4710                 break;
4711         case SCI_Enable_DAA:
4712         case SCI_Enable_Mixer:
4713         case SCI_Enable_EEPROM:
4714                 if (!SCI_WaitHighSCI(j))
4715                         return 0;
4716                 break;
4717         default:
4718                 return 0;
4719                 break;
4720         }
4721         return 1;
4722 }
4723
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726         if (!SCI_Control(j, SCI_End))
4727                 return 0;
4728
4729         if (!SCI_WaitLowSCI(j))
4730                 return 0;
4731
4732         return 1;
4733 }
4734
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737         int reg = (val & 0x1F00) >> 8;
4738         return j->mix.vol[reg];
4739 }
4740
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743         BYTES bytes;
4744
4745         bytes.high = (val & 0x1F00) >> 8;
4746         bytes.low = val & 0x00FF;
4747
4748         /* save mixer value so we can get back later on */
4749         j->mix.vol[bytes.high] = bytes.low;
4750
4751         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4752
4753         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4754
4755         SCI_Control(j, SCI_Enable_Mixer);
4756
4757         SCI_Control(j, SCI_End);
4758
4759         return 0;
4760 }
4761
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766         if (!SCI_Control(j, SCI_Enable_DAA))
4767                 return 0;
4768         else
4769                 return 1;
4770 }
4771
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774         BYTES bytes;
4775
4776         switch (j->daa_mode) {
4777         case SOP_PU_SLEEP:
4778                 bytes.high = 0x14;
4779                 break;
4780         case SOP_PU_RINGING:
4781                 bytes.high = 0x54;
4782                 break;
4783         case SOP_PU_CONVERSATION:
4784                 bytes.high = 0x94;
4785                 break;
4786         case SOP_PU_PULSEDIALING:
4787                 bytes.high = 0xD4;
4788                 break;
4789         }
4790
4791         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794         case 0:
4795                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796                 break;
4797         case 1:
4798                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799                 break;
4800         case 2:
4801                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802                 break;
4803         case 3:
4804                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805                 break;
4806         }
4807
4808         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810         if (!daa_load(&bytes, j))
4811                 return 0;
4812
4813         if (!SCI_Prepare(j))
4814                 return 0;
4815
4816         return 1;
4817 }
4818
4819 static char daa_int_read(IXJ *j)
4820 {
4821         BYTES bytes;
4822
4823         if (!SCI_Prepare(j))
4824                 return 0;
4825
4826         bytes.high = 0x38;
4827         bytes.low = 0x00;
4828         outb_p(bytes.high, j->XILINXbase + 0x03);
4829         outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831         if (!SCI_Control(j, SCI_Enable_DAA))
4832                 return 0;
4833
4834         bytes.high = inb_p(j->XILINXbase + 0x03);
4835         bytes.low = inb_p(j->XILINXbase + 0x02);
4836         if (bytes.low != ALISDAA_ID_BYTE) {
4837                 if (ixjdebug & 0x0001)
4838                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839                 return 0;
4840         }
4841         if (!SCI_Control(j, SCI_Enable_DAA))
4842                 return 0;
4843         if (!SCI_Control(j, SCI_End))
4844                 return 0;
4845
4846         bytes.high = inb_p(j->XILINXbase + 0x03);
4847         bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851         return 1;
4852 }
4853
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856         IXJ_WORD wdata;
4857         BYTES bytes;
4858
4859         if (!SCI_Prepare(j))
4860                 return 0;
4861
4862         switch (j->daa_mode) {
4863         case SOP_PU_SLEEP:
4864                 bytes.high = 0x30 + cr;
4865                 break;
4866         case SOP_PU_RINGING:
4867                 bytes.high = 0x70 + cr;
4868                 break;
4869         case SOP_PU_CONVERSATION:
4870                 bytes.high = 0xB0 + cr;
4871                 break;
4872         case SOP_PU_PULSEDIALING:
4873                 bytes.high = 0xF0 + cr;
4874                 break;
4875         }
4876
4877         bytes.low = 0x00;
4878
4879         outb_p(bytes.high, j->XILINXbase + 0x03);
4880         outb_p(bytes.low, j->XILINXbase + 0x02);
4881
4882         if (!SCI_Control(j, SCI_Enable_DAA))
4883                 return 0;
4884
4885         bytes.high = inb_p(j->XILINXbase + 0x03);
4886         bytes.low = inb_p(j->XILINXbase + 0x02);
4887         if (bytes.low != ALISDAA_ID_BYTE) {
4888                 if (ixjdebug & 0x0001)
4889                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4890                 return 0;
4891         }
4892         if (!SCI_Control(j, SCI_Enable_DAA))
4893                 return 0;
4894         if (!SCI_Control(j, SCI_End))
4895                 return 0;
4896
4897         wdata.word = inw_p(j->XILINXbase + 0x02);
4898
4899         switch(cr){
4900                 case 5:
4901                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4902                         break;
4903                 case 4:
4904                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4905                         break;
4906                 case 3:
4907                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4908                         break;
4909                 case 2:
4910                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4911                         break;
4912                 case 1:
4913                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4914                         break;
4915                 case 0:
4916                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4917                         break;
4918                 default:
4919                         return 0;
4920         }
4921         return 1;
4922 }
4923
4924 static int ixj_daa_cid_reset(IXJ *j)
4925 {
4926         int i;
4927         BYTES bytes;
4928
4929         if (ixjdebug & 0x0002)
4930                 printk("DAA Clearing CID ram\n");
4931
4932         if (!SCI_Prepare(j))
4933                 return 0;
4934
4935         bytes.high = 0x58;
4936         bytes.low = 0x00;
4937         outb_p(bytes.high, j->XILINXbase + 0x03);
4938         outb_p(bytes.low, j->XILINXbase + 0x02);
4939
4940         if (!SCI_Control(j, SCI_Enable_DAA))
4941                 return 0;
4942
4943         if (!SCI_WaitHighSCI(j))
4944                 return 0;
4945
4946         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4947                 bytes.high = bytes.low = 0x00;
4948                 outb_p(bytes.high, j->XILINXbase + 0x03);
4949
4950                 if (i < ALISDAA_CALLERID_SIZE - 1)
4951                         outb_p(bytes.low, j->XILINXbase + 0x02);
4952
4953                 if (!SCI_Control(j, SCI_Enable_DAA))
4954                         return 0;
4955
4956                 if (!SCI_WaitHighSCI(j))
4957                         return 0;
4958
4959         }
4960
4961         if (!SCI_Control(j, SCI_End))
4962                 return 0;
4963
4964         if (ixjdebug & 0x0002)
4965                 printk("DAA CID ram cleared\n");
4966
4967         return 1;
4968 }
4969
4970 static int ixj_daa_cid_read(IXJ *j)
4971 {
4972         int i;
4973         BYTES bytes;
4974         char CID[ALISDAA_CALLERID_SIZE], mContinue;
4975         char *pIn, *pOut;
4976
4977         if (!SCI_Prepare(j))
4978                 return 0;
4979
4980         bytes.high = 0x78;
4981         bytes.low = 0x00;
4982         outb_p(bytes.high, j->XILINXbase + 0x03);
4983         outb_p(bytes.low, j->XILINXbase + 0x02);
4984
4985         if (!SCI_Control(j, SCI_Enable_DAA))
4986                 return 0;
4987
4988         if (!SCI_WaitHighSCI(j))
4989                 return 0;
4990
4991         bytes.high = inb_p(j->XILINXbase + 0x03);
4992         bytes.low = inb_p(j->XILINXbase + 0x02);
4993         if (bytes.low != ALISDAA_ID_BYTE) {
4994                 if (ixjdebug & 0x0001)
4995                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4996                 return 0;
4997         }
4998         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4999                 bytes.high = bytes.low = 0x00;
5000                 outb_p(bytes.high, j->XILINXbase + 0x03);
5001                 outb_p(bytes.low, j->XILINXbase + 0x02);
5002
5003                 if (!SCI_Control(j, SCI_Enable_DAA))
5004                         return 0;
5005
5006                 if (!SCI_WaitHighSCI(j))
5007                         return 0;
5008
5009                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5010                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5011         }
5012
5013         if (!SCI_Control(j, SCI_End))
5014                 return 0;
5015
5016         pIn = CID;
5017         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5018         mContinue = 1;
5019         while (mContinue) {
5020                 if ((pIn[1] & 0x03) == 0x01) {
5021                         pOut[0] = pIn[0];
5022                 }
5023                 if ((pIn[2] & 0x0c) == 0x04) {
5024                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5025                 }
5026                 if ((pIn[3] & 0x30) == 0x10) {
5027                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5028                 }
5029                 if ((pIn[4] & 0xc0) == 0x40) {
5030                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5031                 } else {
5032                         mContinue = FALSE;
5033                 }
5034                 pIn += 5, pOut += 4;
5035         }
5036         memset(&j->cid, 0, sizeof(PHONE_CID));
5037         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5038         pOut += 4;
5039         strncpy(j->cid.month, pOut, 2);
5040         pOut += 2;
5041         strncpy(j->cid.day, pOut, 2);
5042         pOut += 2;
5043         strncpy(j->cid.hour, pOut, 2);
5044         pOut += 2;
5045         strncpy(j->cid.min, pOut, 2);
5046         pOut += 3;
5047         j->cid.numlen = *pOut;
5048         pOut += 1;
5049         strncpy(j->cid.number, pOut, j->cid.numlen);
5050         pOut += j->cid.numlen + 1;
5051         j->cid.namelen = *pOut;
5052         pOut += 1;
5053         strncpy(j->cid.name, pOut, j->cid.namelen);
5054
5055         ixj_daa_cid_reset(j);
5056         return 1;
5057 }
5058
5059 static char daa_get_version(IXJ *j)
5060 {
5061         BYTES bytes;
5062
5063         if (!SCI_Prepare(j))
5064                 return 0;
5065
5066         bytes.high = 0x35;
5067         bytes.low = 0x00;
5068         outb_p(bytes.high, j->XILINXbase + 0x03);
5069         outb_p(bytes.low, j->XILINXbase + 0x02);
5070
5071         if (!SCI_Control(j, SCI_Enable_DAA))
5072                 return 0;
5073
5074         bytes.high = inb_p(j->XILINXbase + 0x03);
5075         bytes.low = inb_p(j->XILINXbase + 0x02);
5076         if (bytes.low != ALISDAA_ID_BYTE) {
5077                 if (ixjdebug & 0x0001)
5078                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5079                 return 0;
5080         }
5081         if (!SCI_Control(j, SCI_Enable_DAA))
5082                 return 0;
5083
5084         if (!SCI_Control(j, SCI_End))
5085                 return 0;
5086
5087         bytes.high = inb_p(j->XILINXbase + 0x03);
5088         bytes.low = inb_p(j->XILINXbase + 0x02);
5089         if (ixjdebug & 0x0002)
5090                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5091         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5092         return bytes.high;
5093 }
5094
5095 static int daa_set_mode(IXJ *j, int mode)
5096 {
5097         /* NOTE:
5098               The DAA *MUST* be in the conversation mode if the
5099               PSTN line is to be seized (PSTN line off-hook).
5100               Taking the PSTN line off-hook while the DAA is in
5101               a mode other than conversation mode will cause a
5102               hardware failure of the ALIS-A part.
5103
5104            NOTE:
5105               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5106               if the PSTN line is on-hook.  Failure to have the PSTN line
5107               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5108               ALIS-A part.
5109         */
5110
5111         BYTES bytes;
5112
5113         j->flags.pstn_rmr = 0;
5114
5115         if (!SCI_Prepare(j))
5116                 return 0;
5117
5118         switch (mode) {
5119         case SOP_PU_RESET:
5120                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5121
5122                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5123                 j->pld_slicw.bits.rly2 = 0;
5124                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5125                 bytes.high = 0x10;
5126                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5127                 daa_load(&bytes, j);
5128                 if (!SCI_Prepare(j))
5129                         return 0;
5130
5131                 j->daa_mode = SOP_PU_SLEEP;
5132                 break;
5133         case SOP_PU_SLEEP:
5134                 if(j->daa_mode == SOP_PU_SLEEP)
5135                 {
5136                         break;
5137                 }
5138                 if (ixjdebug & 0x0008)
5139                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5140 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5141                 {
5142                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5143
5144                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5145                         j->pld_slicw.bits.rly2 = 0;
5146                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5147                         bytes.high = 0x10;
5148                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5149                         daa_load(&bytes, j);
5150                         if (!SCI_Prepare(j))
5151                                 return 0;
5152                 }
5153                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5154
5155                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5156                 j->pld_slicw.bits.rly2 = 0;
5157                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5158                 bytes.high = 0x10;
5159                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5160                 daa_load(&bytes, j);
5161                 if (!SCI_Prepare(j))
5162                         return 0;
5163
5164                 j->daa_mode = SOP_PU_SLEEP;
5165                 j->flags.pstn_ringing = 0;
5166                 j->ex.bits.pstn_ring = 0;
5167                 j->pstn_sleeptil = jiffies + (hertz / 4);
5168                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5169                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5170                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5171                 break;
5172         case SOP_PU_RINGING:
5173                 if (ixjdebug & 0x0008)
5174                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5175                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5176
5177                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5178                 j->pld_slicw.bits.rly2 = 0;
5179                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5180                 bytes.high = 0x50;
5181                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5182                 daa_load(&bytes, j);
5183                 if (!SCI_Prepare(j))
5184                         return 0;
5185                 j->daa_mode = SOP_PU_RINGING;
5186                 break;
5187         case SOP_PU_CONVERSATION:
5188                 if (ixjdebug & 0x0008)
5189                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5190                 bytes.high = 0x90;
5191                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5192                 daa_load(&bytes, j);
5193                 if (!SCI_Prepare(j))
5194                         return 0;
5195                 j->pld_slicw.bits.rly2 = 1;
5196                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5197                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5198
5199                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5200                 j->daa_mode = SOP_PU_CONVERSATION;
5201                 j->flags.pstn_ringing = 0;
5202                 j->ex.bits.pstn_ring = 0;
5203                 j->pstn_sleeptil = jiffies;
5204                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5205                 break;
5206         case SOP_PU_PULSEDIALING:
5207                 if (ixjdebug & 0x0008)
5208                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5209                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5210
5211                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5212                 j->pld_slicw.bits.rly2 = 0;
5213                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5214                 bytes.high = 0xD0;
5215                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5216                 daa_load(&bytes, j);
5217                 if (!SCI_Prepare(j))
5218                         return 0;
5219                 j->daa_mode = SOP_PU_PULSEDIALING;
5220                 break;
5221         default:
5222                 break;
5223         }
5224         return 1;
5225 }
5226
5227 static int ixj_daa_write(IXJ *j)
5228 {
5229         BYTES bytes;
5230
5231         j->flags.pstncheck = 1;
5232
5233         daa_set_mode(j, SOP_PU_SLEEP);
5234
5235         if (!SCI_Prepare(j))
5236                 return 0;
5237
5238         outb_p(j->pld_scrw.byte, j->XILINXbase);
5239
5240         bytes.high = 0x14;
5241         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5242         if (!daa_load(&bytes, j))
5243                 return 0;
5244
5245         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5246         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5247         if (!daa_load(&bytes, j))
5248                 return 0;
5249
5250         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5251         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5252         if (!daa_load(&bytes, j))
5253                 return 0;
5254
5255         if (!SCI_Prepare(j))
5256                 return 0;
5257
5258         bytes.high = 0x1F;
5259         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5260         if (!daa_load(&bytes, j))
5261                 return 0;
5262
5263         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5264         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5265         if (!daa_load(&bytes, j))
5266                 return 0;
5267
5268         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5269         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5270         if (!daa_load(&bytes, j))
5271                 return 0;
5272
5273         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5274         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5275         if (!daa_load(&bytes, j))
5276                 return 0;
5277
5278         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5279         bytes.low = 0x00;
5280         if (!daa_load(&bytes, j))
5281                 return 0;
5282
5283         if (!SCI_Prepare(j))
5284                 return 0;
5285
5286         bytes.high = 0x00;
5287         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5288         if (!daa_load(&bytes, j))
5289                 return 0;
5290
5291         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5292         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5293         if (!daa_load(&bytes, j))
5294                 return 0;
5295
5296         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5297         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5298         if (!daa_load(&bytes, j))
5299                 return 0;
5300
5301         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5302         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5303         if (!daa_load(&bytes, j))
5304                 return 0;
5305
5306         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5307         bytes.low = 0x00;
5308         if (!daa_load(&bytes, j))
5309                 return 0;
5310
5311         if (!SCI_Control(j, SCI_End))
5312                 return 0;
5313         if (!SCI_WaitLowSCI(j))
5314                 return 0;
5315
5316         bytes.high = 0x01;
5317         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5318         if (!daa_load(&bytes, j))
5319                 return 0;
5320
5321         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5322         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5323         if (!daa_load(&bytes, j))
5324                 return 0;
5325
5326         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5327         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5328         if (!daa_load(&bytes, j))
5329                 return 0;
5330
5331         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5332         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5333         if (!daa_load(&bytes, j))
5334                 return 0;
5335
5336         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5337         bytes.low = 0x00;
5338         if (!daa_load(&bytes, j))
5339                 return 0;
5340
5341         if (!SCI_Control(j, SCI_End))
5342                 return 0;
5343         if (!SCI_WaitLowSCI(j))
5344                 return 0;
5345
5346         bytes.high = 0x02;
5347         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5348         if (!daa_load(&bytes, j))
5349                 return 0;
5350
5351         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5352         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5353         if (!daa_load(&bytes, j))
5354                 return 0;
5355
5356         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5357         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5358         if (!daa_load(&bytes, j))
5359                 return 0;
5360
5361         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5362         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5363         if (!daa_load(&bytes, j))
5364                 return 0;
5365
5366         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5367         bytes.low = 0x00;
5368         if (!daa_load(&bytes, j))
5369                 return 0;
5370
5371         if (!SCI_Control(j, SCI_End))
5372                 return 0;
5373         if (!SCI_WaitLowSCI(j))
5374                 return 0;
5375
5376         bytes.high = 0x03;
5377         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5378         if (!daa_load(&bytes, j))
5379                 return 0;
5380
5381         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5382         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5383         if (!daa_load(&bytes, j))
5384                 return 0;
5385
5386         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5387         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5388         if (!daa_load(&bytes, j))
5389                 return 0;
5390
5391         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5392         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5393         if (!daa_load(&bytes, j))
5394                 return 0;
5395
5396         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5397         bytes.low = 0x00;
5398         if (!daa_load(&bytes, j))
5399                 return 0;
5400
5401         if (!SCI_Control(j, SCI_End))
5402                 return 0;
5403         if (!SCI_WaitLowSCI(j))
5404                 return 0;
5405
5406         bytes.high = 0x04;
5407         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5408         if (!daa_load(&bytes, j))
5409                 return 0;
5410
5411         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5412         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5413         if (!daa_load(&bytes, j))
5414                 return 0;
5415
5416         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5417         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5418         if (!daa_load(&bytes, j))
5419                 return 0;
5420
5421         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5422         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5423         if (!daa_load(&bytes, j))
5424                 return 0;
5425
5426         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5427         bytes.low = 0x00;
5428         if (!daa_load(&bytes, j))
5429                 return 0;
5430
5431         if (!SCI_Control(j, SCI_End))
5432                 return 0;
5433         if (!SCI_WaitLowSCI(j))
5434                 return 0;
5435
5436         bytes.high = 0x05;
5437         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5438         if (!daa_load(&bytes, j))
5439                 return 0;
5440
5441         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5442         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5443         if (!daa_load(&bytes, j))
5444                 return 0;
5445
5446         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5447         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5448         if (!daa_load(&bytes, j))
5449                 return 0;
5450
5451         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5452         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5453         if (!daa_load(&bytes, j))
5454                 return 0;
5455
5456         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5457         bytes.low = 0x00;
5458         if (!daa_load(&bytes, j))
5459                 return 0;
5460
5461         if (!SCI_Control(j, SCI_End))
5462                 return 0;
5463         if (!SCI_WaitLowSCI(j))
5464                 return 0;
5465
5466         bytes.high = 0x06;
5467         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5468         if (!daa_load(&bytes, j))
5469                 return 0;
5470
5471         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5472         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5473         if (!daa_load(&bytes, j))
5474                 return 0;
5475
5476         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5477         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5478         if (!daa_load(&bytes, j))
5479                 return 0;
5480
5481         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5482         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5483         if (!daa_load(&bytes, j))
5484                 return 0;
5485
5486         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5487         bytes.low = 0x00;
5488         if (!daa_load(&bytes, j))
5489                 return 0;
5490
5491         if (!SCI_Control(j, SCI_End))
5492                 return 0;
5493         if (!SCI_WaitLowSCI(j))
5494                 return 0;
5495
5496         bytes.high = 0x07;
5497         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5498         if (!daa_load(&bytes, j))
5499                 return 0;
5500
5501         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5502         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5503         if (!daa_load(&bytes, j))
5504                 return 0;
5505
5506         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5507         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5508         if (!daa_load(&bytes, j))
5509                 return 0;
5510
5511         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5512         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5513         if (!daa_load(&bytes, j))
5514                 return 0;
5515
5516         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5517         bytes.low = 0x00;
5518         if (!daa_load(&bytes, j))
5519                 return 0;
5520
5521         if (!SCI_Control(j, SCI_End))
5522                 return 0;
5523         if (!SCI_WaitLowSCI(j))
5524                 return 0;
5525
5526         bytes.high = 0x08;
5527         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5528         if (!daa_load(&bytes, j))
5529                 return 0;
5530
5531         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5532         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5533         if (!daa_load(&bytes, j))
5534                 return 0;
5535
5536         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5537         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5538         if (!daa_load(&bytes, j))
5539                 return 0;
5540
5541         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5542         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5543         if (!daa_load(&bytes, j))
5544                 return 0;
5545
5546         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5547         bytes.low = 0x00;
5548         if (!daa_load(&bytes, j))
5549                 return 0;
5550
5551         if (!SCI_Control(j, SCI_End))
5552                 return 0;
5553         if (!SCI_WaitLowSCI(j))
5554                 return 0;
5555
5556         bytes.high = 0x09;
5557         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5558         if (!daa_load(&bytes, j))
5559                 return 0;
5560
5561         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5562         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5563         if (!daa_load(&bytes, j))
5564                 return 0;
5565
5566         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5567         bytes.low = 0x00;
5568         if (!daa_load(&bytes, j))
5569                 return 0;
5570
5571         if (!SCI_Control(j, SCI_End))
5572                 return 0;
5573         if (!SCI_WaitLowSCI(j))
5574                 return 0;
5575
5576         bytes.high = 0x0A;
5577         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5578         if (!daa_load(&bytes, j))
5579                 return 0;
5580
5581         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5582         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5583         if (!daa_load(&bytes, j))
5584                 return 0;
5585
5586         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5587         bytes.low = 0x00;
5588         if (!daa_load(&bytes, j))
5589                 return 0;
5590
5591         if (!SCI_Control(j, SCI_End))
5592                 return 0;
5593         if (!SCI_WaitLowSCI(j))
5594                 return 0;
5595
5596         bytes.high = 0x0B;
5597         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5598         if (!daa_load(&bytes, j))
5599                 return 0;
5600
5601         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5602         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5603         if (!daa_load(&bytes, j))
5604                 return 0;
5605
5606         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5607         bytes.low = 0x00;
5608         if (!daa_load(&bytes, j))
5609                 return 0;
5610
5611         if (!SCI_Control(j, SCI_End))
5612                 return 0;
5613         if (!SCI_WaitLowSCI(j))
5614                 return 0;
5615
5616         bytes.high = 0x0C;
5617         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5618         if (!daa_load(&bytes, j))
5619                 return 0;
5620
5621         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5622         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5623         if (!daa_load(&bytes, j))
5624                 return 0;
5625
5626         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5627         bytes.low = 0x00;
5628         if (!daa_load(&bytes, j))
5629                 return 0;
5630
5631         if (!SCI_Control(j, SCI_End))
5632                 return 0;
5633         if (!SCI_WaitLowSCI(j))
5634                 return 0;
5635
5636         bytes.high = 0x0D;
5637         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5638         if (!daa_load(&bytes, j))
5639                 return 0;
5640
5641         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5642         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5643         if (!daa_load(&bytes, j))
5644                 return 0;
5645
5646         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5647         bytes.low = 0x00;
5648         if (!daa_load(&bytes, j))
5649                 return 0;
5650
5651         if (!SCI_Control(j, SCI_End))
5652                 return 0;
5653         if (!SCI_WaitLowSCI(j))
5654                 return 0;
5655
5656         bytes.high = 0x0E;
5657         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5658         if (!daa_load(&bytes, j))
5659                 return 0;
5660
5661         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5662         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5663         if (!daa_load(&bytes, j))
5664                 return 0;
5665
5666         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5667         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5668         if (!daa_load(&bytes, j))
5669                 return 0;
5670
5671         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5672         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5673         if (!daa_load(&bytes, j))
5674                 return 0;
5675
5676         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5677         bytes.low = 0x00;
5678         if (!daa_load(&bytes, j))
5679                 return 0;
5680
5681         if (!SCI_Control(j, SCI_End))
5682                 return 0;
5683         if (!SCI_WaitLowSCI(j))
5684                 return 0;
5685
5686         bytes.high = 0x0F;
5687         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5688         if (!daa_load(&bytes, j))
5689                 return 0;
5690
5691         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5692         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5693         if (!daa_load(&bytes, j))
5694                 return 0;
5695
5696         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5697         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5698         if (!daa_load(&bytes, j))
5699                 return 0;
5700
5701         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5702         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5703         if (!daa_load(&bytes, j))
5704                 return 0;
5705
5706         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5707         bytes.low = 0x00;
5708         if (!daa_load(&bytes, j))
5709                 return 0;
5710
5711         udelay(32);
5712         j->pld_scrr.byte = inb_p(j->XILINXbase);
5713         if (!SCI_Control(j, SCI_End))
5714                 return 0;
5715
5716         outb_p(j->pld_scrw.byte, j->XILINXbase);
5717
5718         if (ixjdebug & 0x0002)
5719                 printk("DAA Coefficients Loaded\n");
5720
5721         j->flags.pstncheck = 0;
5722         return 1;
5723 }
5724
5725 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5726 {
5727         j->tone_off_time = arg;
5728         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5729
5730                 return -1;
5731         if (ixj_WriteDSPCommand(arg, j))
5732                 return -1;
5733         return 0;
5734 }
5735
5736 static int ixj_get_tone_on(IXJ *j)
5737 {
5738         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5739
5740                 return -1;
5741         return 0;
5742 }
5743
5744 static int ixj_get_tone_off(IXJ *j)
5745 {
5746         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5747
5748                 return -1;
5749         return 0;
5750 }
5751
5752 static void ixj_busytone(IXJ *j)
5753 {
5754         j->flags.ringback = 0;
5755         j->flags.dialtone = 0;
5756         j->flags.busytone = 1;
5757         ixj_set_tone_on(0x07D0, j);
5758         ixj_set_tone_off(0x07D0, j);
5759         ixj_play_tone(j, 27);
5760 }
5761
5762 static void ixj_dialtone(IXJ *j)
5763 {
5764         j->flags.ringback = 0;
5765         j->flags.dialtone = 1;
5766         j->flags.busytone = 0;
5767         if (j->dsp.low == 0x20) {
5768                 return;
5769         } else {
5770                 ixj_set_tone_on(0xFFFF, j);
5771                 ixj_set_tone_off(0x0000, j);
5772                 ixj_play_tone(j, 25);
5773         }
5774 }
5775
5776 static void ixj_cpt_stop(IXJ *j)
5777 {
5778         if(j->tone_state || j->tone_cadence_state)
5779         {
5780                 j->flags.dialtone = 0;
5781                 j->flags.busytone = 0;
5782                 j->flags.ringback = 0;
5783                 ixj_set_tone_on(0x0001, j);
5784                 ixj_set_tone_off(0x0000, j);
5785                 ixj_play_tone(j, 0);
5786                 j->tone_state = j->tone_cadence_state = 0;
5787                 if (j->cadence_t) {
5788                         kfree(j->cadence_t->ce);
5789                         kfree(j->cadence_t);
5790                         j->cadence_t = NULL;
5791                 }
5792         }
5793         if (j->play_mode == -1 && j->rec_mode == -1)
5794                 idle(j);
5795         if (j->play_mode != -1 && j->dsp.low == 0x20)
5796                 ixj_play_start(j);
5797         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5798                 ixj_record_start(j);
5799 }
5800
5801 static void ixj_ringback(IXJ *j)
5802 {
5803         j->flags.busytone = 0;
5804         j->flags.dialtone = 0;
5805         j->flags.ringback = 1;
5806         ixj_set_tone_on(0x0FA0, j);
5807         ixj_set_tone_off(0x2EE0, j);
5808         ixj_play_tone(j, 26);
5809 }
5810
5811 static void ixj_testram(IXJ *j)
5812 {
5813         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5814 }
5815
5816 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5817 {
5818         ixj_cadence *lcp;
5819         IXJ_CADENCE_ELEMENT __user *cep;
5820         IXJ_CADENCE_ELEMENT *lcep;
5821         IXJ_TONE ti;
5822         int err;
5823
5824         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5825         if (lcp == NULL)
5826                 return -ENOMEM;
5827
5828         err = -EFAULT;
5829         if (copy_from_user(&lcp->elements_used,
5830                            &cp->elements_used, sizeof(int)))
5831                 goto out;
5832         if (copy_from_user(&lcp->termination,
5833                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5834                 goto out;
5835         if (get_user(cep, &cp->ce))
5836                 goto out;
5837
5838         err = -EINVAL;
5839         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5840                 goto out;
5841
5842         err = -ENOMEM;
5843         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5844         if (!lcep)
5845                 goto out;
5846
5847         err = -EFAULT;
5848         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5849                 goto out1;
5850
5851         if (j->cadence_t) {
5852                 kfree(j->cadence_t->ce);
5853                 kfree(j->cadence_t);
5854         }
5855         lcp->ce = (void *) lcep;
5856         j->cadence_t = lcp;
5857         j->tone_cadence_state = 0;
5858         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5859         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5860         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5861                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5862                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5863                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5864                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5865                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5866                 ixj_init_tone(j, &ti);
5867         }
5868         ixj_play_tone(j, lcp->ce[0].index);
5869         return 1;
5870 out1:
5871         kfree(lcep);
5872 out:
5873         kfree(lcp);
5874         return err;
5875 }
5876
5877 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5878 {
5879         IXJ_FILTER_CADENCE *lcp;
5880         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5881         if (lcp == NULL) {
5882                 if(ixjdebug & 0x0001) {
5883                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5884                 }
5885                 return -ENOMEM;
5886         }
5887         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5888                 if(ixjdebug & 0x0001) {
5889                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5890                 }
5891                 kfree(lcp);
5892                 return -EFAULT;
5893         }
5894         if (lcp->filter > 5) {
5895                 if(ixjdebug & 0x0001) {
5896                         printk(KERN_INFO "Cadence out of range\n");
5897                 }
5898                 kfree(lcp);
5899                 return -1;
5900         }
5901         j->cadence_f[lcp->filter].state = 0;
5902         j->cadence_f[lcp->filter].enable = lcp->enable;
5903         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5904         j->cadence_f[lcp->filter].on1 = lcp->on1;
5905         j->cadence_f[lcp->filter].on1min = 0;
5906         j->cadence_f[lcp->filter].on1max = 0;
5907         j->cadence_f[lcp->filter].off1 = lcp->off1;
5908         j->cadence_f[lcp->filter].off1min = 0;
5909         j->cadence_f[lcp->filter].off1max = 0;
5910         j->cadence_f[lcp->filter].on2 = lcp->on2;
5911         j->cadence_f[lcp->filter].on2min = 0;
5912         j->cadence_f[lcp->filter].on2max = 0;
5913         j->cadence_f[lcp->filter].off2 = lcp->off2;
5914         j->cadence_f[lcp->filter].off2min = 0;
5915         j->cadence_f[lcp->filter].off2max = 0;
5916         j->cadence_f[lcp->filter].on3 = lcp->on3;
5917         j->cadence_f[lcp->filter].on3min = 0;
5918         j->cadence_f[lcp->filter].on3max = 0;
5919         j->cadence_f[lcp->filter].off3 = lcp->off3;
5920         j->cadence_f[lcp->filter].off3min = 0;
5921         j->cadence_f[lcp->filter].off3max = 0;
5922         if(ixjdebug & 0x0002) {
5923                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5924         }
5925         kfree(lcp);
5926         return 0;
5927 }
5928
5929 static void add_caps(IXJ *j)
5930 {
5931         j->caps = 0;
5932         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5933         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5934         j->caplist[j->caps].captype = vendor;
5935         j->caplist[j->caps].handle = j->caps++;
5936         j->caplist[j->caps].captype = device;
5937         switch (j->cardtype) {
5938         case QTI_PHONEJACK:
5939                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5940                 break;
5941         case QTI_LINEJACK:
5942                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5943                 break;
5944         case QTI_PHONEJACK_LITE:
5945                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5946                 break;
5947         case QTI_PHONEJACK_PCI:
5948                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5949                 break;
5950         case QTI_PHONECARD:
5951                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5952                 break;
5953         }
5954         j->caplist[j->caps].cap = j->cardtype;
5955         j->caplist[j->caps].handle = j->caps++;
5956         strcpy(j->caplist[j->caps].desc, "POTS");
5957         j->caplist[j->caps].captype = port;
5958         j->caplist[j->caps].cap = pots;
5959         j->caplist[j->caps].handle = j->caps++;
5960
5961         /* add devices that can do speaker/mic */
5962         switch (j->cardtype) {
5963         case QTI_PHONEJACK:
5964         case QTI_LINEJACK:
5965         case QTI_PHONEJACK_PCI:
5966         case QTI_PHONECARD:
5967                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5968                 j->caplist[j->caps].captype = port;
5969                 j->caplist[j->caps].cap = speaker;
5970                 j->caplist[j->caps].handle = j->caps++;
5971         default:
5972                 break;
5973         }
5974
5975         /* add devices that can do handset */
5976         switch (j->cardtype) {
5977         case QTI_PHONEJACK:
5978                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5979                 j->caplist[j->caps].captype = port;
5980                 j->caplist[j->caps].cap = handset;
5981                 j->caplist[j->caps].handle = j->caps++;
5982                 break;
5983         default:
5984                 break;
5985         }
5986
5987         /* add devices that can do PSTN */
5988         switch (j->cardtype) {
5989         case QTI_LINEJACK:
5990                 strcpy(j->caplist[j->caps].desc, "PSTN");
5991                 j->caplist[j->caps].captype = port;
5992                 j->caplist[j->caps].cap = pstn;
5993                 j->caplist[j->caps].handle = j->caps++;
5994                 break;
5995         default:
5996                 break;
5997         }
5998
5999         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6000         strcpy(j->caplist[j->caps].desc, "ULAW");
6001         j->caplist[j->caps].captype = codec;
6002         j->caplist[j->caps].cap = ULAW;
6003         j->caplist[j->caps].handle = j->caps++;
6004
6005         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6006         j->caplist[j->caps].captype = codec;
6007         j->caplist[j->caps].cap = LINEAR16;
6008         j->caplist[j->caps].handle = j->caps++;
6009
6010         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6011         j->caplist[j->caps].captype = codec;
6012         j->caplist[j->caps].cap = LINEAR8;
6013         j->caplist[j->caps].handle = j->caps++;
6014
6015         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6016         j->caplist[j->caps].captype = codec;
6017         j->caplist[j->caps].cap = WSS;
6018         j->caplist[j->caps].handle = j->caps++;
6019
6020         /* software ALAW codec, made from ULAW */
6021         strcpy(j->caplist[j->caps].desc, "ALAW");
6022         j->caplist[j->caps].captype = codec;
6023         j->caplist[j->caps].cap = ALAW;
6024         j->caplist[j->caps].handle = j->caps++;
6025
6026         /* version 12 of the 8020 does the following codecs in a broken way */
6027         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6028                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6029                 j->caplist[j->caps].captype = codec;
6030                 j->caplist[j->caps].cap = G723_63;
6031                 j->caplist[j->caps].handle = j->caps++;
6032
6033                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6034                 j->caplist[j->caps].captype = codec;
6035                 j->caplist[j->caps].cap = G723_53;
6036                 j->caplist[j->caps].handle = j->caps++;
6037
6038                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6039                 j->caplist[j->caps].captype = codec;
6040                 j->caplist[j->caps].cap = TS48;
6041                 j->caplist[j->caps].handle = j->caps++;
6042
6043                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6044                 j->caplist[j->caps].captype = codec;
6045                 j->caplist[j->caps].cap = TS41;
6046                 j->caplist[j->caps].handle = j->caps++;
6047         }
6048
6049         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6050         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6051                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6052                 j->caplist[j->caps].captype = codec;
6053                 j->caplist[j->caps].cap = TS85;
6054                 j->caplist[j->caps].handle = j->caps++;
6055         }
6056
6057         /* 8021 chips can do G728 */
6058         if (j->dsp.low == 0x21) {
6059                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6060                 j->caplist[j->caps].captype = codec;
6061                 j->caplist[j->caps].cap = G728;
6062                 j->caplist[j->caps].handle = j->caps++;
6063         }
6064
6065         /* 8021/8022 chips can do G729 if loaded */
6066         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6067                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6068                 j->caplist[j->caps].captype = codec;
6069                 j->caplist[j->caps].cap = G729;
6070                 j->caplist[j->caps].handle = j->caps++;
6071         }
6072         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6073                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6074                 j->caplist[j->caps].captype = codec;
6075                 j->caplist[j->caps].cap = G729B;
6076                 j->caplist[j->caps].handle = j->caps++;
6077         }
6078 }
6079
6080 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6081 {
6082         int cnt;
6083         int retval = 0;
6084         for (cnt = 0; cnt < j->caps; cnt++) {
6085                 if (pcreq->captype == j->caplist[cnt].captype
6086                     && pcreq->cap == j->caplist[cnt].cap) {
6087                         retval = 1;
6088                         break;
6089                 }
6090         }
6091         return retval;
6092 }
6093
6094 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6095 {
6096         IXJ_TONE ti;
6097         IXJ_FILTER jf;
6098         IXJ_FILTER_RAW jfr;
6099         void __user *argp = (void __user *)arg;
6100
6101         unsigned int raise, mant;
6102         unsigned int minor = iminor(inode);
6103         int board = NUM(inode);
6104
6105         IXJ *j = get_ixj(NUM(inode));
6106
6107         int retval = 0;
6108
6109         /*
6110          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6111          *    This is necessary to keep the DSP from locking up.
6112          */
6113         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6114                 set_current_state(TASK_INTERRUPTIBLE);
6115                 schedule_timeout(1);
6116         }
6117         if (ixjdebug & 0x0040)
6118                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6119         if (minor >= IXJMAX) {
6120                 clear_bit(board, &j->busyflags);
6121                 return -ENODEV;
6122         }
6123         /*
6124          *    Check ioctls only root can use.
6125          */
6126         if (!capable(CAP_SYS_ADMIN)) {
6127                 switch (cmd) {
6128                 case IXJCTL_TESTRAM:
6129                 case IXJCTL_HZ:
6130                         retval = -EPERM;
6131                 }
6132         }
6133         switch (cmd) {
6134         case IXJCTL_TESTRAM:
6135                 ixj_testram(j);
6136                 retval = (j->ssr.high << 8) + j->ssr.low;
6137                 break;
6138         case IXJCTL_CARDTYPE:
6139                 retval = j->cardtype;
6140                 break;
6141         case IXJCTL_SERIAL:
6142                 retval = j->serial;
6143                 break;
6144         case IXJCTL_VERSION:
6145                 {
6146                         char arg_str[100];
6147                         snprintf(arg_str, sizeof(arg_str),
6148                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6149                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6150                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6151                                 retval = -EFAULT;
6152                 }
6153                 break;
6154         case PHONE_RING_CADENCE:
6155                 j->ring_cadence = arg;
6156                 break;
6157         case IXJCTL_CIDCW:
6158                 if(arg) {
6159                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6160                                 retval = -EFAULT;
6161                                 break;
6162                         }
6163                 } else {
6164                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6165                 }
6166                 ixj_write_cidcw(j);
6167                 break;
6168         /* Binary compatbility */
6169         case OLD_PHONE_RING_START:
6170                 arg = 0;
6171                 /* Fall through */
6172         case PHONE_RING_START:
6173                 if(arg) {
6174                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175                                 retval = -EFAULT;
6176                                 break;
6177                         }
6178                         ixj_write_cid(j);
6179                 } else {
6180                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6181                 }
6182                 ixj_ring_start(j);
6183                 break;
6184         case PHONE_RING_STOP:
6185                 j->flags.cringing = 0;
6186                 if(j->cadence_f[5].enable) {
6187                         j->cadence_f[5].state = 0;
6188                 }
6189                 ixj_ring_off(j);
6190                 break;
6191         case PHONE_RING:
6192                 retval = ixj_ring(j);
6193                 break;
6194         case PHONE_EXCEPTION:
6195                 retval = j->ex.bytes;
6196                 if(j->ex.bits.flash) {
6197                         j->flash_end = 0;
6198                         j->ex.bits.flash = 0;
6199                 }
6200                 j->ex.bits.pstn_ring = 0;
6201                 j->ex.bits.caller_id = 0;
6202                 j->ex.bits.pstn_wink = 0;
6203                 j->ex.bits.f0 = 0;
6204                 j->ex.bits.f1 = 0;
6205                 j->ex.bits.f2 = 0;
6206                 j->ex.bits.f3 = 0;
6207                 j->ex.bits.fc0 = 0;
6208                 j->ex.bits.fc1 = 0;
6209                 j->ex.bits.fc2 = 0;
6210                 j->ex.bits.fc3 = 0;
6211                 j->ex.bits.reserved = 0;
6212                 break;
6213         case PHONE_HOOKSTATE:
6214                 j->ex.bits.hookstate = 0;
6215                 retval = j->hookstate;  //j->r_hook;
6216                 break;
6217         case IXJCTL_SET_LED:
6218                 LED_SetState(arg, j);
6219                 break;
6220         case PHONE_FRAME:
6221                 retval = set_base_frame(j, arg);
6222                 break;
6223         case PHONE_REC_CODEC:
6224                 retval = set_rec_codec(j, arg);
6225                 break;
6226         case PHONE_VAD:
6227                 ixj_vad(j, arg);
6228                 break;
6229         case PHONE_REC_START:
6230                 ixj_record_start(j);
6231                 break;
6232         case PHONE_REC_STOP:
6233                 ixj_record_stop(j);
6234                 break;
6235         case PHONE_REC_DEPTH:
6236                 set_rec_depth(j, arg);
6237                 break;
6238         case PHONE_REC_VOLUME:
6239                 if(arg == -1) {
6240                         retval = get_rec_volume(j);
6241                 }
6242                 else {
6243                         set_rec_volume(j, arg);
6244                         retval = arg;
6245                 }
6246                 break;
6247         case PHONE_REC_VOLUME_LINEAR:
6248                 if(arg == -1) {
6249                         retval = get_rec_volume_linear(j);
6250                 }
6251                 else {
6252                         set_rec_volume_linear(j, arg);
6253                         retval = arg;
6254                 }
6255                 break;
6256         case IXJCTL_DTMF_PRESCALE:
6257                 if(arg == -1) {
6258                         retval = get_dtmf_prescale(j);
6259                 }
6260                 else {
6261                         set_dtmf_prescale(j, arg);
6262                         retval = arg;
6263                 }
6264                 break;
6265         case PHONE_REC_LEVEL:
6266                 retval = get_rec_level(j);
6267                 break;
6268         case IXJCTL_SC_RXG:
6269                 retval = ixj_siadc(j, arg);
6270                 break;
6271         case IXJCTL_SC_TXG:
6272                 retval = ixj_sidac(j, arg);
6273                 break;
6274         case IXJCTL_AEC_START:
6275                 ixj_aec_start(j, arg);
6276                 break;
6277         case IXJCTL_AEC_STOP:
6278                 aec_stop(j);
6279                 break;
6280         case IXJCTL_AEC_GET_LEVEL:
6281                 retval = j->aec_level;
6282                 break;
6283         case PHONE_PLAY_CODEC:
6284                 retval = set_play_codec(j, arg);
6285                 break;
6286         case PHONE_PLAY_START:
6287                 retval = ixj_play_start(j);
6288                 break;
6289         case PHONE_PLAY_STOP:
6290                 ixj_play_stop(j);
6291                 break;
6292         case PHONE_PLAY_DEPTH:
6293                 set_play_depth(j, arg);
6294                 break;
6295         case PHONE_PLAY_VOLUME:
6296                 if(arg == -1) {
6297                         retval = get_play_volume(j);
6298                 }
6299                 else {
6300                         set_play_volume(j, arg);
6301                         retval = arg;
6302                 }
6303                 break;
6304         case PHONE_PLAY_VOLUME_LINEAR:
6305                 if(arg == -1) {
6306                         retval = get_play_volume_linear(j);
6307                 }
6308                 else {
6309                         set_play_volume_linear(j, arg);
6310                         retval = arg;
6311                 }
6312                 break;
6313         case PHONE_PLAY_LEVEL:
6314                 retval = get_play_level(j);
6315                 break;
6316         case IXJCTL_DSP_TYPE:
6317                 retval = (j->dsp.high << 8) + j->dsp.low;
6318                 break;
6319         case IXJCTL_DSP_VERSION:
6320                 retval = (j->ver.high << 8) + j->ver.low;
6321                 break;
6322         case IXJCTL_HZ:
6323                 hertz = arg;
6324                 break;
6325         case IXJCTL_RATE:
6326                 if (arg > hertz)
6327                         retval = -1;
6328                 else
6329                         samplerate = arg;
6330                 break;
6331         case IXJCTL_DRYBUFFER_READ:
6332                 put_user(j->drybuffer, (unsigned long __user *) argp);
6333                 break;
6334         case IXJCTL_DRYBUFFER_CLEAR:
6335                 j->drybuffer = 0;
6336                 break;
6337         case IXJCTL_FRAMES_READ:
6338                 put_user(j->framesread, (unsigned long __user *) argp);
6339                 break;
6340         case IXJCTL_FRAMES_WRITTEN:
6341                 put_user(j->frameswritten, (unsigned long __user *) argp);
6342                 break;
6343         case IXJCTL_READ_WAIT:
6344                 put_user(j->read_wait, (unsigned long __user *) argp);
6345                 break;
6346         case IXJCTL_WRITE_WAIT:
6347                 put_user(j->write_wait, (unsigned long __user *) argp);
6348                 break;
6349         case PHONE_MAXRINGS:
6350                 j->maxrings = arg;
6351                 break;
6352         case PHONE_SET_TONE_ON_TIME:
6353                 ixj_set_tone_on(arg, j);
6354                 break;
6355         case PHONE_SET_TONE_OFF_TIME:
6356                 ixj_set_tone_off(arg, j);
6357                 break;
6358         case PHONE_GET_TONE_ON_TIME:
6359                 if (ixj_get_tone_on(j)) {
6360                         retval = -1;
6361                 } else {
6362                         retval = (j->ssr.high << 8) + j->ssr.low;
6363                 }
6364                 break;
6365         case PHONE_GET_TONE_OFF_TIME:
6366                 if (ixj_get_tone_off(j)) {
6367                         retval = -1;
6368                 } else {
6369                         retval = (j->ssr.high << 8) + j->ssr.low;
6370                 }
6371                 break;
6372         case PHONE_PLAY_TONE:
6373                 if (!j->tone_state)
6374                         retval = ixj_play_tone(j, arg);
6375                 else
6376                         retval = -1;
6377                 break;
6378         case PHONE_GET_TONE_STATE:
6379                 retval = j->tone_state;
6380                 break;
6381         case PHONE_DTMF_READY:
6382                 retval = j->ex.bits.dtmf_ready;
6383                 break;
6384         case PHONE_GET_DTMF:
6385                 if (ixj_hookstate(j)) {
6386                         if (j->dtmf_rp != j->dtmf_wp) {
6387                                 retval = j->dtmfbuffer[j->dtmf_rp];
6388                                 j->dtmf_rp++;
6389                                 if (j->dtmf_rp == 79)
6390                                         j->dtmf_rp = 0;
6391                                 if (j->dtmf_rp == j->dtmf_wp) {
6392                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6393                                 }
6394                         }
6395                 }
6396                 break;
6397         case PHONE_GET_DTMF_ASCII:
6398                 if (ixj_hookstate(j)) {
6399                         if (j->dtmf_rp != j->dtmf_wp) {
6400                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6401                                 case 10:
6402                                         retval = 42;    /* '*'; */
6403
6404                                         break;
6405                                 case 11:
6406                                         retval = 48;    /*'0'; */
6407
6408                                         break;
6409                                 case 12:
6410                                         retval = 35;    /*'#'; */
6411
6412                                         break;
6413                                 case 28:
6414                                         retval = 65;    /*'A'; */
6415
6416                                         break;
6417                                 case 29:
6418                                         retval = 66;    /*'B'; */
6419
6420                                         break;
6421                                 case 30:
6422                                         retval = 67;    /*'C'; */
6423
6424                                         break;
6425                                 case 31:
6426                                         retval = 68;    /*'D'; */
6427
6428                                         break;
6429                                 default:
6430                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6431                                         break;
6432                                 }
6433                                 j->dtmf_rp++;
6434                                 if (j->dtmf_rp == 79)
6435                                         j->dtmf_rp = 0;
6436                                 if(j->dtmf_rp == j->dtmf_wp)
6437                                 {
6438                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6439                                 }
6440                         }
6441                 }
6442                 break;
6443         case PHONE_DTMF_OOB:
6444                 j->flags.dtmf_oob = arg;
6445                 break;
6446         case PHONE_DIALTONE:
6447                 ixj_dialtone(j);
6448                 break;
6449         case PHONE_BUSY:
6450                 ixj_busytone(j);
6451                 break;
6452         case PHONE_RINGBACK:
6453                 ixj_ringback(j);
6454                 break;
6455         case PHONE_WINK:
6456                 if(j->cardtype == QTI_PHONEJACK)
6457                         retval = -1;
6458                 else
6459                         retval = ixj_wink(j);
6460                 break;
6461         case PHONE_CPT_STOP:
6462                 ixj_cpt_stop(j);
6463                 break;
6464         case PHONE_QUERY_CODEC:
6465         {
6466                 struct phone_codec_data pd;
6467                 int val;
6468                 int proto_size[] = {
6469                         -1,
6470                         12, 10, 16, 9, 8, 48, 5,
6471                         40, 40, 80, 40, 40, 6
6472                 };
6473                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6474                         retval = -EFAULT;
6475                         break;
6476                 }
6477                 if(pd.type<1 || pd.type>13) {
6478                         retval = -EPROTONOSUPPORT;
6479                         break;
6480                 }
6481                 if(pd.type<G729)
6482                         val=proto_size[pd.type];
6483                 else switch(j->baseframe.low)
6484                 {
6485                         case 0xA0:val=2*proto_size[pd.type];break;
6486                         case 0x50:val=proto_size[pd.type];break;
6487                         default:val=proto_size[pd.type]*3;break;
6488                 }
6489                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6490                 if(copy_to_user(argp, &pd, sizeof(pd)))
6491                         retval = -EFAULT;
6492                 break;
6493         }
6494         case IXJCTL_DSP_IDLE:
6495                 idle(j);
6496                 break;
6497         case IXJCTL_MIXER:
6498                 if ((arg & 0xff) == 0xff)
6499                         retval = ixj_get_mixer(arg, j);
6500                 else
6501                         ixj_mixer(arg, j);
6502                 break;
6503         case IXJCTL_DAA_COEFF_SET:
6504                 switch (arg) {
6505                 case DAA_US:
6506                         DAA_Coeff_US(j);
6507                         retval = ixj_daa_write(j);
6508                         break;
6509                 case DAA_UK:
6510                         DAA_Coeff_UK(j);
6511                         retval = ixj_daa_write(j);
6512                         break;
6513                 case DAA_FRANCE:
6514                         DAA_Coeff_France(j);
6515                         retval = ixj_daa_write(j);
6516                         break;
6517                 case DAA_GERMANY:
6518                         DAA_Coeff_Germany(j);
6519                         retval = ixj_daa_write(j);
6520                         break;
6521                 case DAA_AUSTRALIA:
6522                         DAA_Coeff_Australia(j);
6523                         retval = ixj_daa_write(j);
6524                         break;
6525                 case DAA_JAPAN:
6526                         DAA_Coeff_Japan(j);
6527                         retval = ixj_daa_write(j);
6528                         break;
6529                 default:
6530                         retval = 1;
6531                         break;
6532                 }
6533                 break;
6534         case IXJCTL_DAA_AGAIN:
6535                 ixj_daa_cr4(j, arg | 0x02);
6536                 break;
6537         case IXJCTL_PSTN_LINETEST:
6538                 retval = ixj_linetest(j);
6539                 break;
6540         case IXJCTL_VMWI:
6541                 ixj_write_vmwi(j, arg);
6542                 break;
6543         case IXJCTL_CID:
6544                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6545                         retval = -EFAULT;
6546                 j->ex.bits.caller_id = 0;
6547                 break;
6548         case IXJCTL_WINK_DURATION:
6549                 j->winktime = arg;
6550                 break;
6551         case IXJCTL_PORT:
6552                 if (arg)
6553                         retval = ixj_set_port(j, arg);
6554                 else
6555                         retval = j->port;
6556                 break;
6557         case IXJCTL_POTS_PSTN:
6558                 retval = ixj_set_pots(j, arg);
6559                 break;
6560         case PHONE_CAPABILITIES:
6561                 add_caps(j);
6562                 retval = j->caps;
6563                 break;
6564         case PHONE_CAPABILITIES_LIST:
6565                 add_caps(j);
6566                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6567                         retval = -EFAULT;
6568                 break;
6569         case PHONE_CAPABILITIES_CHECK:
6570                 {
6571                         struct phone_capability cap;
6572                         if (copy_from_user(&cap, argp, sizeof(cap)))
6573                                 retval = -EFAULT;
6574                         else {
6575                                 add_caps(j);
6576                                 retval = capabilities_check(j, &cap);
6577                         }
6578                 }
6579                 break;
6580         case PHONE_PSTN_SET_STATE:
6581                 daa_set_mode(j, arg);
6582                 break;
6583         case PHONE_PSTN_GET_STATE:
6584                 retval = j->daa_mode;
6585                 j->ex.bits.pstn_ring = 0;
6586                 break;
6587         case IXJCTL_SET_FILTER:
6588                 if (copy_from_user(&jf, argp, sizeof(jf)))
6589                         retval = -EFAULT;
6590                 retval = ixj_init_filter(j, &jf);
6591                 break;
6592         case IXJCTL_SET_FILTER_RAW:
6593                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6594                         retval = -EFAULT;
6595                 else
6596                         retval = ixj_init_filter_raw(j, &jfr);
6597                 break;
6598         case IXJCTL_GET_FILTER_HIST:
6599                 if(arg<0||arg>3)
6600                         retval = -EINVAL;
6601                 else
6602                         retval = j->filter_hist[arg];
6603                 break;
6604         case IXJCTL_INIT_TONE:
6605                 if (copy_from_user(&ti, argp, sizeof(ti)))
6606                         retval = -EFAULT;
6607                 else
6608                         retval = ixj_init_tone(j, &ti);
6609                 break;
6610         case IXJCTL_TONE_CADENCE:
6611                 retval = ixj_build_cadence(j, argp);
6612                 break;
6613         case IXJCTL_FILTER_CADENCE:
6614                 retval = ixj_build_filter_cadence(j, argp);
6615                 break;
6616         case IXJCTL_SIGCTL:
6617                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6618                         retval = -EFAULT;
6619                         break;
6620                 }
6621                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6622                 if(j->sigdef.event < 33) {
6623                         raise = 1;
6624                         for(mant = 0; mant < j->sigdef.event; mant++){
6625                                 raise *= 2;
6626                         }
6627                         if(j->sigdef.signal)
6628                                 j->ex_sig.bytes |= raise;
6629                         else
6630                                 j->ex_sig.bytes &= (raise^0xffff);
6631                 }
6632                 break;
6633         case IXJCTL_INTERCOM_STOP:
6634                 if(arg < 0 || arg >= IXJMAX)
6635                         return -EINVAL;
6636                 j->intercom = -1;
6637                 ixj_record_stop(j);
6638                 ixj_play_stop(j);
6639                 idle(j);
6640                 get_ixj(arg)->intercom = -1;
6641                 ixj_record_stop(get_ixj(arg));
6642                 ixj_play_stop(get_ixj(arg));
6643                 idle(get_ixj(arg));
6644                 break;
6645         case IXJCTL_INTERCOM_START:
6646                 if(arg < 0 || arg >= IXJMAX)
6647                         return -EINVAL;
6648                 j->intercom = arg;
6649                 ixj_record_start(j);
6650                 ixj_play_start(j);
6651                 get_ixj(arg)->intercom = board;
6652                 ixj_play_start(get_ixj(arg));
6653                 ixj_record_start(get_ixj(arg));
6654                 break;
6655         }
6656         if (ixjdebug & 0x0040)
6657                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6658         clear_bit(board, &j->busyflags);
6659         return retval;
6660 }
6661
6662 static int ixj_fasync(int fd, struct file *file_p, int mode)
6663 {
6664         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6665
6666         return fasync_helper(fd, file_p, mode, &j->async_queue);
6667 }
6668
6669 static struct file_operations ixj_fops =
6670 {
6671         .owner          = THIS_MODULE,
6672         .read           = ixj_enhanced_read,
6673         .write          = ixj_enhanced_write,
6674         .poll           = ixj_poll,
6675         .ioctl          = ixj_ioctl,
6676         .release        = ixj_release,
6677         .fasync         = ixj_fasync
6678 };
6679
6680 static int ixj_linetest(IXJ *j)
6681 {
6682         j->flags.pstncheck = 1; /* Testing */
6683         j->flags.pstn_present = 0; /* Assume the line is not there */
6684
6685         daa_int_read(j);        /*Clear DAA Interrupt flags */
6686         /* */
6687         /* Hold all relays in the normally de-energized position. */
6688         /* */
6689
6690         j->pld_slicw.bits.rly1 = 0;
6691         j->pld_slicw.bits.rly2 = 0;
6692         j->pld_slicw.bits.rly3 = 0;
6693         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6694         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6695
6696         outb_p(j->pld_scrw.byte, j->XILINXbase);
6697         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6698         if (j->pld_slicr.bits.potspstn) {
6699                 j->flags.pots_pstn = 1;
6700                 j->flags.pots_correct = 0;
6701                 LED_SetState(0x4, j);
6702         } else {
6703                 j->flags.pots_pstn = 0;
6704                 j->pld_slicw.bits.rly1 = 0;
6705                 j->pld_slicw.bits.rly2 = 0;
6706                 j->pld_slicw.bits.rly3 = 1;
6707                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6708                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6709
6710                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6711                 daa_set_mode(j, SOP_PU_CONVERSATION);
6712                 msleep(1000);
6713                 daa_int_read(j);
6714                 daa_set_mode(j, SOP_PU_RESET);
6715                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6716                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6717                         LED_SetState(0x4, j);
6718                         j->pld_slicw.bits.rly3 = 0;
6719                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6720                 } else {
6721                         j->flags.pots_correct = 1;
6722                         LED_SetState(0x8, j);
6723                         j->pld_slicw.bits.rly1 = 1;
6724                         j->pld_slicw.bits.rly2 = 0;
6725                         j->pld_slicw.bits.rly3 = 0;
6726                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6727                 }
6728         }
6729         j->pld_slicw.bits.rly3 = 0;
6730         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731         daa_set_mode(j, SOP_PU_CONVERSATION);
6732         msleep(1000);
6733         daa_int_read(j);
6734         daa_set_mode(j, SOP_PU_RESET);
6735         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6736                 j->pstn_sleeptil = jiffies + (hertz / 4);
6737                 j->flags.pstn_present = 1;
6738         } else {
6739                 j->flags.pstn_present = 0;
6740         }
6741         if (j->flags.pstn_present) {
6742                 if (j->flags.pots_correct) {
6743                         LED_SetState(0xA, j);
6744                 } else {
6745                         LED_SetState(0x6, j);
6746                 }
6747         } else {
6748                 if (j->flags.pots_correct) {
6749                         LED_SetState(0x9, j);
6750                 } else {
6751                         LED_SetState(0x5, j);
6752                 }
6753         }
6754         j->flags.pstncheck = 0; /* Testing */
6755         return j->flags.pstn_present;
6756 }
6757
6758 static int ixj_selfprobe(IXJ *j)
6759 {
6760         unsigned short cmd;
6761         int cnt;
6762         BYTES bytes;
6763
6764         init_waitqueue_head(&j->poll_q);
6765         init_waitqueue_head(&j->read_q);
6766         init_waitqueue_head(&j->write_q);
6767
6768         while(atomic_read(&j->DSPWrite) > 0)
6769                 atomic_dec(&j->DSPWrite);
6770         if (ixjdebug & 0x0002)
6771                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6772         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6773
6774         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6775                 return -1;
6776 /* The read values of the SSR should be 0x00 for the IDLE command */
6777         if (j->ssr.low || j->ssr.high)
6778                 return -1;
6779         if (ixjdebug & 0x0002)
6780                 printk(KERN_INFO "Get Device ID Code\n");
6781         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6782                 return -1;
6783         j->dsp.low = j->ssr.low;
6784         j->dsp.high = j->ssr.high;
6785         if (ixjdebug & 0x0002)
6786                 printk(KERN_INFO "Get Device Version Code\n");
6787         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6788                 return -1;
6789         j->ver.low = j->ssr.low;
6790         j->ver.high = j->ssr.high;
6791         if (!j->cardtype) {
6792                 if (j->dsp.low == 0x21) {
6793                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6794                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6795 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6796                         bytes.low = inb_p(j->XILINXbase + 0x02);
6797                         if (bytes.low == bytes.high)    /*  Register is read only on */
6798                                 /*  Internet PhoneJack Lite */
6799                          {
6800                                 j->cardtype = QTI_PHONEJACK_LITE;
6801                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6802                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6803                                         return -1;
6804                                 }
6805                                 j->pld_slicw.pcib.e1 = 1;
6806                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6807                         } else {
6808                                 j->cardtype = QTI_LINEJACK;
6809
6810                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6811                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812                                         return -1;
6813                                 }
6814                         }
6815                 } else if (j->dsp.low == 0x22) {
6816                         j->cardtype = QTI_PHONEJACK_PCI;
6817                         request_region(j->XILINXbase, 4, "ixj control");
6818                         j->pld_slicw.pcib.e1 = 1;
6819                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6820                 } else
6821                         j->cardtype = QTI_PHONEJACK;
6822         } else {
6823                 switch (j->cardtype) {
6824                 case QTI_PHONEJACK:
6825                         if (!j->dsp.low != 0x20) {
6826                                 j->dsp.high = 0x80;
6827                                 j->dsp.low = 0x20;
6828                                 ixj_WriteDSPCommand(0x3800, j);
6829                                 j->ver.low = j->ssr.low;
6830                                 j->ver.high = j->ssr.high;
6831                         }
6832                         break;
6833                 case QTI_LINEJACK:
6834                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6835                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6836                                 return -1;
6837                         }
6838                         break;
6839                 case QTI_PHONEJACK_LITE:
6840                 case QTI_PHONEJACK_PCI:
6841                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6842                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6843                                 return -1;
6844                         }
6845                         j->pld_slicw.pcib.e1 = 1;
6846                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6847                         break;
6848                 case QTI_PHONECARD:
6849                         break;
6850                 }
6851         }
6852         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6853                 if (ixjdebug & 0x0002)
6854                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6855                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6856                         return -1;
6857                 if (ixjdebug & 0x0002)
6858                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6859                 if (j->cardtype == QTI_PHONEJACK) {
6860                         cmd = 0x9FF2;
6861                 } else {
6862                         cmd = 0x9FF5;
6863                 }
6864                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6865                         return -1;
6866         } else {
6867                 if (set_base_frame(j, 30) != 30)
6868                         return -1;
6869                 if (ixjdebug & 0x0002)
6870                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6871                 if (j->cardtype == QTI_PHONECARD) {
6872                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6873                                 return -1;
6874                 }
6875                 if (j->cardtype == QTI_LINEJACK) {
6876                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6877                                 return -1;
6878                         if (ixjdebug & 0x0002)
6879                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6880                         j->pld_clock.byte = 0;
6881                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6882                 }
6883         }
6884
6885         if (j->dsp.low == 0x20) {
6886                 if (ixjdebug & 0x0002)
6887                         printk(KERN_INFO "Configure GPIO pins\n");
6888                 j->gpio.bytes.high = 0x09;
6889 /*  bytes.low = 0xEF;  0xF7 */
6890                 j->gpio.bits.gpio1 = 1;
6891                 j->gpio.bits.gpio2 = 1;
6892                 j->gpio.bits.gpio3 = 0;
6893                 j->gpio.bits.gpio4 = 1;
6894                 j->gpio.bits.gpio5 = 1;
6895                 j->gpio.bits.gpio6 = 1;
6896                 j->gpio.bits.gpio7 = 1;
6897                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6898                 if (ixjdebug & 0x0002)
6899                         printk(KERN_INFO "Enable SLIC\n");
6900                 j->gpio.bytes.high = 0x0B;
6901                 j->gpio.bytes.low = 0x00;
6902                 j->gpio.bits.gpio1 = 0;
6903                 j->gpio.bits.gpio2 = 1;
6904                 j->gpio.bits.gpio5 = 0;
6905                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6906                 j->port = PORT_POTS;
6907         } else {
6908                 if (j->cardtype == QTI_LINEJACK) {
6909                         LED_SetState(0x1, j);
6910                         msleep(100);
6911                         LED_SetState(0x2, j);
6912                         msleep(100);
6913                         LED_SetState(0x4, j);
6914                         msleep(100);
6915                         LED_SetState(0x8, j);
6916                         msleep(100);
6917                         LED_SetState(0x0, j);
6918                         daa_get_version(j);
6919                         if (ixjdebug & 0x0002)
6920                                 printk("Loading DAA Coefficients\n");
6921                         DAA_Coeff_US(j);
6922                         if (!ixj_daa_write(j)) {
6923                                 printk("DAA write failed on board %d\n", j->board);
6924                                 return -1;
6925                         }
6926                         if(!ixj_daa_cid_reset(j)) {
6927                                 printk("DAA CID reset failed on board %d\n", j->board);
6928                                 return -1;
6929                         }
6930                         j->flags.pots_correct = 0;
6931                         j->flags.pstn_present = 0;
6932                         ixj_linetest(j);
6933                         if (j->flags.pots_correct) {
6934                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6935
6936                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6937                                 j->pld_slicw.bits.rly1 = 1;
6938                                 j->pld_slicw.bits.spken = 1;
6939                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6940                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6941 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6942                                 j->port = PORT_POTS;
6943                         }
6944                         ixj_set_port(j, PORT_PSTN);
6945                         ixj_set_pots(j, 1);
6946                         if (ixjdebug & 0x0002)
6947                                 printk(KERN_INFO "Enable Mixer\n");
6948                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6949                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6950
6951                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6952                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6953
6954                         ixj_mixer(0x0480, j);   /*FM Left mute */
6955                         ixj_mixer(0x0580, j);   /*FM Right mute */
6956
6957                         ixj_mixer(0x0680, j);   /*CD Left mute */
6958                         ixj_mixer(0x0780, j);   /*CD Right mute */
6959
6960                         ixj_mixer(0x0880, j);   /*Line Left mute */
6961                         ixj_mixer(0x0980, j);   /*Line Right mute */
6962
6963                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6964                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6965
6966                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6967                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6968
6969                         ixj_mixer(0x0E80, j);   /*Mic mute */
6970
6971                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6972
6973                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6974                         ixj_mixer(0x110C, j);
6975
6976
6977                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6978                         ixj_mixer(0x1401, j);
6979
6980                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6981                         ixj_mixer(0x1501, j);
6982
6983                         ixj_mixer(0x1700, j);   /*Clock select */
6984
6985                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6986
6987                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6988
6989                         if (ixjdebug & 0x0002)
6990                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6991                         j->cadence_f[4].state = 0;
6992                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
6993                         j->cadence_f[4].off1 = 0;
6994                         j->cadence_f[4].on2 = 0;
6995                         j->cadence_f[4].off2 = 0;
6996                         j->cadence_f[4].on3 = 0;
6997                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
6998                         j->pstn_last_rmr = jiffies;
6999
7000                 } else {
7001                         if (j->cardtype == QTI_PHONECARD) {
7002                                 ixj_WriteDSPCommand(0xCF07, j);
7003                                 ixj_WriteDSPCommand(0x00B0, j);
7004                                 ixj_set_port(j, PORT_SPEAKER);
7005                         } else {
7006                                 ixj_set_port(j, PORT_POTS);
7007                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7008 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7009                         }
7010                 }
7011         }
7012
7013         j->intercom = -1;
7014         j->framesread = j->frameswritten = 0;
7015         j->read_wait = j->write_wait = 0;
7016         j->rxreadycheck = j->txreadycheck = 0;
7017
7018         /* initialise the DTMF prescale to a sensible value */
7019         if (j->cardtype == QTI_LINEJACK) {
7020                 set_dtmf_prescale(j, 0x10);
7021         } else {
7022                 set_dtmf_prescale(j, 0x40);
7023         }
7024         set_play_volume(j, 0x100);
7025         set_rec_volume(j, 0x100);
7026
7027         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7028                 return -1;
7029 /* The read values of the SSR should be 0x00 for the IDLE command */
7030         if (j->ssr.low || j->ssr.high)
7031                 return -1;
7032
7033         if (ixjdebug & 0x0002)
7034                 printk(KERN_INFO "Enable Line Monitor\n");
7035
7036         if (ixjdebug & 0x0002)
7037                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7038
7039         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7040                 return -1;
7041
7042         if (ixjdebug & 0x002)
7043                 printk(KERN_INFO "Enable DTMF Detectors\n");
7044
7045         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7046                 return -1;
7047
7048         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7049                 return -1;
7050
7051         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7052
7053         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7054
7055         j->ex.bits.dtmf_ready = 0;
7056         j->dtmf_state = 0;
7057         j->dtmf_wp = j->dtmf_rp = 0;
7058         j->rec_mode = j->play_mode = -1;
7059         j->flags.ringing = 0;
7060         j->maxrings = MAXRINGS;
7061         j->ring_cadence = USA_RING_CADENCE;
7062         j->drybuffer = 0;
7063         j->winktime = 320;
7064         j->flags.dtmf_oob = 0;
7065         for (cnt = 0; cnt < 4; cnt++)
7066                 j->cadence_f[cnt].enable = 0;
7067         /* must be a device on the specified address */
7068         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7069
7070         /* Set up the default signals for events */
7071         for (cnt = 0; cnt < 35; cnt++)
7072                 j->ixj_signals[cnt] = SIGIO;
7073
7074         /* Set the excetion signal enable flags */
7075         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7076         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 =
7077         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;
7078 #ifdef IXJ_DYN_ALLOC
7079         j->fskdata = NULL;
7080 #endif
7081         j->fskdcnt = 0;
7082         j->cidcw_wait = 0;
7083
7084         /* Register with the Telephony for Linux subsystem */
7085         j->p.f_op = &ixj_fops;
7086         j->p.open = ixj_open;
7087         j->p.board = j->board;
7088         phone_register_device(&j->p, PHONE_UNIT_ANY);
7089
7090         ixj_init_timer(j);
7091         ixj_add_timer(j);
7092         return 0;
7093 }
7094
7095 /*
7096  *      Exported service for pcmcia card handling
7097  */
7098
7099 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7100 {
7101         IXJ *j = ixj_alloc();
7102
7103         j->board = 0;
7104
7105         j->DSPbase = dsp;
7106         j->XILINXbase = xilinx;
7107         j->cardtype = QTI_PHONECARD;
7108         ixj_selfprobe(j);
7109         return j;
7110 }
7111
7112 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7113
7114 static int ixj_get_status_proc(char *buf)
7115 {
7116         int len;
7117         int cnt;
7118         IXJ *j;
7119         len = 0;
7120         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7121         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7122         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7123         len += sprintf(buf + len, "\nUsing old telephony API");
7124         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7125
7126         for (cnt = 0; cnt < IXJMAX; cnt++) {
7127                 j = get_ixj(cnt);
7128                 if(j==NULL)
7129                         continue;
7130                 if (j->DSPbase) {
7131                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7132                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7133                         if (j->cardtype != QTI_PHONEJACK)
7134                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7135                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7136                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7137                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7138                         switch (j->cardtype) {
7139                         case (QTI_PHONEJACK):
7140                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7141                                 break;
7142                         case (QTI_LINEJACK):
7143                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7144                                 if (j->flags.g729_loaded)
7145                                         len += sprintf(buf + len, " w/G.729 A/B");
7146                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7147                                 break;
7148                         case (QTI_PHONEJACK_LITE):
7149                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7150                                 if (j->flags.g729_loaded)
7151                                         len += sprintf(buf + len, " w/G.729 A/B");
7152                                 break;
7153                         case (QTI_PHONEJACK_PCI):
7154                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7155                                 if (j->flags.g729_loaded)
7156                                         len += sprintf(buf + len, " w/G.729 A/B");
7157                                 break;
7158                         case (QTI_PHONECARD):
7159                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7160                                 if (j->flags.g729_loaded)
7161                                         len += sprintf(buf + len, " w/G.729 A/B");
7162                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7163                                 if (!j->pccr1.bits.drf)
7164                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7165                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7166                                 break;
7167                         default:
7168                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7169                                 break;
7170                         }
7171                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7172                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7173                         add_caps(j);
7174                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7175                         if (j->dsp.low != 0x20)
7176                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7177                         if (j->flags.cidsent)
7178                                 len += sprintf(buf + len, "\nCaller ID data sent");
7179                         else
7180                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7181
7182                         len += sprintf(buf + len, "\nPlay CODEC ");
7183                         switch (j->play_codec) {
7184                         case G723_63:
7185                                 len += sprintf(buf + len, "G.723.1 6.3");
7186                                 break;
7187                         case G723_53:
7188                                 len += sprintf(buf + len, "G.723.1 5.3");
7189                                 break;
7190                         case TS85:
7191                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7192                                 break;
7193                         case TS48:
7194                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7195                                 break;
7196                         case TS41:
7197                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7198                                 break;
7199                         case G728:
7200                                 len += sprintf(buf + len, "G.728");
7201                                 break;
7202                         case G729:
7203                                 len += sprintf(buf + len, "G.729");
7204                                 break;
7205                         case G729B:
7206                                 len += sprintf(buf + len, "G.729B");
7207                                 break;
7208                         case ULAW:
7209                                 len += sprintf(buf + len, "uLaw");
7210                                 break;
7211                         case ALAW:
7212                                 len += sprintf(buf + len, "aLaw");
7213                                 break;
7214                         case LINEAR16:
7215                                 len += sprintf(buf + len, "16 bit Linear");
7216                                 break;
7217                         case LINEAR8:
7218                                 len += sprintf(buf + len, "8 bit Linear");
7219                                 break;
7220                         case WSS:
7221                                 len += sprintf(buf + len, "Windows Sound System");
7222                                 break;
7223                         default:
7224                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7225                                 break;
7226                         }
7227                         len += sprintf(buf + len, "\nRecord CODEC ");
7228                         switch (j->rec_codec) {
7229                         case G723_63:
7230                                 len += sprintf(buf + len, "G.723.1 6.3");
7231                                 break;
7232                         case G723_53:
7233                                 len += sprintf(buf + len, "G.723.1 5.3");
7234                                 break;
7235                         case TS85:
7236                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7237                                 break;
7238                         case TS48:
7239                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7240                                 break;
7241                         case TS41:
7242                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7243                                 break;
7244                         case G728:
7245                                 len += sprintf(buf + len, "G.728");
7246                                 break;
7247                         case G729:
7248                                 len += sprintf(buf + len, "G.729");
7249                                 break;
7250                         case G729B:
7251                                 len += sprintf(buf + len, "G.729B");
7252                                 break;
7253                         case ULAW:
7254                                 len += sprintf(buf + len, "uLaw");
7255                                 break;
7256                         case ALAW:
7257                                 len += sprintf(buf + len, "aLaw");
7258                                 break;
7259                         case LINEAR16:
7260                                 len += sprintf(buf + len, "16 bit Linear");
7261                                 break;
7262                         case LINEAR8:
7263                                 len += sprintf(buf + len, "8 bit Linear");
7264                                 break;
7265                         case WSS:
7266                                 len += sprintf(buf + len, "Windows Sound System");
7267                                 break;
7268                         default:
7269                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7270                                 break;
7271                         }
7272                         len += sprintf(buf + len, "\nAEC ");
7273                         switch (j->aec_level) {
7274                         case AEC_OFF:
7275                                 len += sprintf(buf + len, "Off");
7276                                 break;
7277                         case AEC_LOW:
7278                                 len += sprintf(buf + len, "Low");
7279                                 break;
7280                         case AEC_MED:
7281                                 len += sprintf(buf + len, "Med");
7282                                 break;
7283                         case AEC_HIGH:
7284                                 len += sprintf(buf + len, "High");
7285                                 break;
7286                         case AEC_AUTO:
7287                                 len += sprintf(buf + len, "Auto");
7288                                 break;
7289                         case AEC_AGC:
7290                                 len += sprintf(buf + len, "AEC/AGC");
7291                                 break;
7292                         default:
7293                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7294                                 break;
7295                         }
7296
7297                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7298                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7299                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7300
7301                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7302
7303                         if (j->cardtype == QTI_LINEJACK) {
7304                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7305                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7306                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7307                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7308                                 switch (j->daa_mode) {
7309                                 case SOP_PU_SLEEP:
7310                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7311                                         break;
7312                                 case SOP_PU_RINGING:
7313                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7314                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7315                                         break;
7316                                 case SOP_PU_CONVERSATION:
7317                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7318                                         break;
7319                                 case SOP_PU_PULSEDIALING:
7320                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7321                                         break;
7322                                 }
7323                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7324                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7325                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7326                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7327                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7328                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7329                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7330                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7331                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7332                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7333                         }
7334                         switch (j->port) {
7335                         case PORT_POTS:
7336                                 len += sprintf(buf + len, "\nPort POTS");
7337                                 break;
7338                         case PORT_PSTN:
7339                                 len += sprintf(buf + len, "\nPort PSTN");
7340                                 break;
7341                         case PORT_SPEAKER:
7342                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7343                                 break;
7344                         case PORT_HANDSET:
7345                                 len += sprintf(buf + len, "\nPort HANDSET");
7346                                 break;
7347                         }
7348                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7349                                 len += sprintf(buf + len, "\nSLIC state ");
7350                                 switch (SLIC_GetState(j)) {
7351                                 case PLD_SLIC_STATE_OC:
7352                                         len += sprintf(buf + len, "OC");
7353                                         break;
7354                                 case PLD_SLIC_STATE_RINGING:
7355                                         len += sprintf(buf + len, "RINGING");
7356                                         break;
7357                                 case PLD_SLIC_STATE_ACTIVE:
7358                                         len += sprintf(buf + len, "ACTIVE");
7359                                         break;
7360                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7361                                         len += sprintf(buf + len, "OHT");
7362                                         break;
7363                                 case PLD_SLIC_STATE_TIPOPEN:
7364                                         len += sprintf(buf + len, "TIPOPEN");
7365                                         break;
7366                                 case PLD_SLIC_STATE_STANDBY:
7367                                         len += sprintf(buf + len, "STANDBY");
7368                                         break;
7369                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7370                                         len += sprintf(buf + len, "APR");
7371                                         break;
7372                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7373                                         len += sprintf(buf + len, "OHTPR");
7374                                         break;
7375                                 default:
7376                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7377                                         break;
7378                                 }
7379                         }
7380                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7381                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7382 #ifdef PERFMON_STATS
7383                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7384                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7385                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7386                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7387                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7388                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7389                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7390                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7391                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7392                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7393                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7394                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7395                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7396                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7397
7398 #endif
7399                         len += sprintf(buf + len, "\n");
7400                 }
7401         }
7402         return len;
7403 }
7404
7405 static int ixj_read_proc(char *page, char **start, off_t off,
7406                               int count, int *eof, void *data)
7407 {
7408         int len = ixj_get_status_proc(page);
7409         if (len <= off+count) *eof = 1;
7410         *start = page + off;
7411         len -= off;
7412         if (len>count) len = count;
7413         if (len<0) len = 0;
7414         return len;
7415 }
7416
7417
7418 static void cleanup(void)
7419 {
7420         int cnt;
7421         IXJ *j;
7422
7423         for (cnt = 0; cnt < IXJMAX; cnt++) {
7424                 j = get_ixj(cnt);
7425                 if(j != NULL && j->DSPbase) {
7426                         if (ixjdebug & 0x0002)
7427                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7428                         del_timer(&j->timer);
7429                         if (j->cardtype == QTI_LINEJACK) {
7430                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7431
7432                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7433                                 j->pld_slicw.bits.rly1 = 0;
7434                                 j->pld_slicw.bits.rly2 = 0;
7435                                 j->pld_slicw.bits.rly3 = 0;
7436                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7437                                 LED_SetState(0x0, j);
7438                                 if (ixjdebug & 0x0002)
7439                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7440                                 release_region(j->XILINXbase, 8);
7441                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7442                                 if (ixjdebug & 0x0002)
7443                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7444                                 release_region(j->XILINXbase, 4);
7445                         }
7446                         kfree(j->read_buffer);
7447                         kfree(j->write_buffer);
7448                         if (j->dev)
7449                                 pnp_device_detach(j->dev);
7450                         if (ixjdebug & 0x0002)
7451                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7452                         phone_unregister_device(&j->p);
7453                         if (ixjdebug & 0x0002)
7454                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7455                         release_region(j->DSPbase, 16);
7456 #ifdef IXJ_DYN_ALLOC
7457                         if (ixjdebug & 0x0002)
7458                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7459                         kfree(j);
7460                         ixj[cnt] = NULL;
7461 #endif
7462                 }
7463         }
7464         if (ixjdebug & 0x0002)
7465                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7466         remove_proc_entry ("ixj", NULL);
7467 }
7468
7469 /* Typedefs */
7470 typedef struct {
7471         BYTE length;
7472         DWORD bits;
7473 } DATABLOCK;
7474
7475 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7476 {
7477         lastLCC = lastLCC & 0xfb;
7478         lastLCC = lastLCC | (byData ? 4 : 0);
7479         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7480
7481         mdelay(1);
7482         lastLCC = lastLCC | 0x01;
7483         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7484
7485         byData = byData << 1;
7486         lastLCC = lastLCC & 0xfe;
7487         mdelay(1);
7488         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7489
7490 }
7491
7492 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7493 {
7494         mdelay(1);
7495         lastLCC = lastLCC | 0x01;
7496         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7497
7498         lastLCC = lastLCC & 0xfe;
7499         mdelay(1);
7500         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7501
7502         return ((inb(wEEPROMAddress) >> 3) & 1);
7503 }
7504
7505 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7506 {
7507         BYTE lastLCC;
7508         WORD wEEPROMAddress = wAddress + 3;
7509         DWORD i;
7510         BYTE byResult;
7511         *pwResult = 0;
7512         lastLCC = inb(wEEPROMAddress);
7513         lastLCC = lastLCC | 0x02;
7514         lastLCC = lastLCC & 0xfe;
7515         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7516
7517         mdelay(1);              /* delay */
7518
7519         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7520         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7521         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7522         for (i = 0; i < 8; i++) {
7523                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7524                 wLoc <<= 1;
7525         }
7526
7527         for (i = 0; i < 16; i++) {
7528                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7529                 *pwResult = (*pwResult << 1) | byResult;
7530         }
7531
7532         mdelay(1);              /* another delay */
7533
7534         lastLCC = lastLCC & 0xfd;
7535         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7536
7537         return 0;
7538 }
7539
7540 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7541 {
7542         WORD wLo, wHi;
7543         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7544                 return 0;
7545         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7546                 return 0;
7547         return (((DWORD) wHi << 16) | wLo);
7548 }
7549
7550 static int dspio[IXJMAX + 1] =
7551 {
7552         0,
7553 };
7554 static int xio[IXJMAX + 1] =
7555 {
7556         0,
7557 };
7558
7559 module_param_array(dspio, int, NULL, 0);
7560 module_param_array(xio, int, NULL, 0);
7561 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7562 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7563 MODULE_LICENSE("GPL");
7564
7565 static void __exit ixj_exit(void)
7566 {
7567         cleanup();
7568 }
7569
7570 static IXJ *new_ixj(unsigned long port)
7571 {
7572         IXJ *res;
7573         if (!request_region(port, 16, "ixj DSP")) {
7574                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7575                 return NULL;
7576         }
7577         res = ixj_alloc();
7578         if (!res) {
7579                 release_region(port, 16);
7580                 printk(KERN_INFO "ixj: out of memory\n");
7581                 return NULL;
7582         }
7583         res->DSPbase = port;
7584         return res;
7585 }
7586
7587 static int __init ixj_probe_isapnp(int *cnt)
7588 {
7589         int probe = 0;
7590         int func = 0x110;
7591         struct pnp_dev *dev = NULL, *old_dev = NULL;
7592
7593         while (1) {
7594                 do {
7595                         IXJ *j;
7596                         int result;
7597
7598                         old_dev = dev;
7599                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7600                                          ISAPNP_FUNCTION(func), old_dev);
7601                         if (!dev || !dev->card)
7602                                 break;
7603                         result = pnp_device_attach(dev);
7604                         if (result < 0) {
7605                                 printk("pnp attach failed %d \n", result);
7606                                 break;
7607                         }
7608                         if (pnp_activate_dev(dev) < 0) {
7609                                 printk("pnp activate failed (out of resources?)\n");
7610                                 pnp_device_detach(dev);
7611                                 return -ENOMEM;
7612                         }
7613
7614                         if (!pnp_port_valid(dev, 0)) {
7615                                 pnp_device_detach(dev);
7616                                 return -ENODEV;
7617                         }
7618
7619                         j = new_ixj(pnp_port_start(dev, 0));
7620                         if (!j)
7621                                 break;
7622
7623                         if (func != 0x110)
7624                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7625
7626                         switch (func) {
7627                         case (0x110):
7628                                 j->cardtype = QTI_PHONEJACK;
7629                                 break;
7630                         case (0x310):
7631                                 j->cardtype = QTI_LINEJACK;
7632                                 break;
7633                         case (0x410):
7634                                 j->cardtype = QTI_PHONEJACK_LITE;
7635                                 break;
7636                         }
7637                         j->board = *cnt;
7638                         probe = ixj_selfprobe(j);
7639                         if(!probe) {
7640                                 j->serial = dev->card->serial;
7641                                 j->dev = dev;
7642                                 switch (func) {
7643                                 case 0x110:
7644                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7645                                         break;
7646                                 case 0x310:
7647                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7648                                         break;
7649                                 case 0x410:
7650                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7651                                         break;
7652                                 }
7653                         }
7654                         ++*cnt;
7655                 } while (dev);
7656                 if (func == 0x410)
7657                         break;
7658                 if (func == 0x310)
7659                         func = 0x410;
7660                 if (func == 0x110)
7661                         func = 0x310;
7662                 dev = NULL;
7663         }
7664         return probe;
7665 }
7666
7667 static int __init ixj_probe_isa(int *cnt)
7668 {
7669         int i, probe;
7670
7671         /* Use passed parameters for older kernels without PnP */
7672         for (i = 0; i < IXJMAX; i++) {
7673                 if (dspio[i]) {
7674                         IXJ *j = new_ixj(dspio[i]);
7675
7676                         if (!j)
7677                                 break;
7678
7679                         j->XILINXbase = xio[i];
7680                         j->cardtype = 0;
7681
7682                         j->board = *cnt;
7683                         probe = ixj_selfprobe(j);
7684                         j->dev = NULL;
7685                         ++*cnt;
7686                 }
7687         }
7688         return 0;
7689 }
7690
7691 static int __init ixj_probe_pci(int *cnt)
7692 {
7693         struct pci_dev *pci = NULL;
7694         int i, probe = 0;
7695         IXJ *j = NULL;
7696
7697         for (i = 0; i < IXJMAX - *cnt; i++) {
7698                 pci = pci_find_device(0x15E2, 0x0500, pci);
7699                 if (!pci)
7700                         break;
7701
7702                 if (pci_enable_device(pci))
7703                         break;
7704                 j = new_ixj(pci_resource_start(pci, 0));
7705                 if (!j)
7706                         break;
7707
7708                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7709                 j->XILINXbase = j->DSPbase + 0x10;
7710                 j->cardtype = QTI_PHONEJACK_PCI;
7711                 j->board = *cnt;
7712                 probe = ixj_selfprobe(j);
7713                 if (!probe)
7714                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7715                 ++*cnt;
7716         }
7717         return probe;
7718 }
7719
7720 static int __init ixj_init(void)
7721 {
7722         int cnt = 0;
7723         int probe = 0;
7724
7725         cnt = 0;
7726
7727         /* These might be no-ops, see above. */
7728         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7729                 return probe;
7730         }
7731         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7732                 return probe;
7733         }
7734         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7735                 return probe;
7736         }
7737         printk(KERN_INFO "ixj driver initialized.\n");
7738         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7739         return probe;
7740 }
7741
7742 module_init(ixj_init);
7743 module_exit(ixj_exit);
7744
7745 static void DAA_Coeff_US(IXJ *j)
7746 {
7747         int i;
7748
7749         j->daa_country = DAA_US;
7750         /*----------------------------------------------- */
7751         /* CAO */
7752         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7753                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7754         }
7755
7756 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7757         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7758         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7759         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7760         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7761         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7762         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7763         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7764         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7765 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7766         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7767         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7772         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7774 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7775         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7776         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7777         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7778         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7779         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7780         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7781         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7782         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7783 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7784         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7785         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7790         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7792 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7793         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7794         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7795         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7796         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7797 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7798         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7799         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7800         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7801         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7802 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7803         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7804         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7805         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7806         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7807         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7808         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7809         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7810         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7811 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7812         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7820 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7822         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7827         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7829 /* ;  (10K, 0.68uF) */
7830         /*  */
7831         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7832         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7833         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7834         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7835         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7836         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7837         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7838         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7839         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7840         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7841         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7842         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7847         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7849
7850         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7851         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7852         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7853         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7854         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7855
7856         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7857 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7858 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7859 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7860 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7861 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7862 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7863 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7864 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7865         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7866 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7867 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7872 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7874 /* */
7875         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7876 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7878 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7880
7881         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7882         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7883         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7884         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7885         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7886         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7887         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7888         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7889         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7890 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7891         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7892         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7897         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7899 /*  */
7900         /* ;CR Registers */
7901         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7902         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7903 /* Config. Reg. 1 (dialing)       (cr1):05 */
7904         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7905 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7906         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7907 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7908         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7909 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7910         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7911         /* Config. Reg. 5 (Version)       (cr5):02 */
7912         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7913         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7914         /*  */
7915         /* ;xr Registers */
7916         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7917
7918         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7919         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7920
7921         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7922 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7923         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7924 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7925         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7926         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7927
7928         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7929 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7930         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7931 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7932         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7933 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7934         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7935         /*  */
7936         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7937         /*                                       12,33,5A,C3 ;  770 Hz   */
7938         /*                                       13,3C,5B,32 ;  852 Hz   */
7939         /*                                       1D,1B,5C,CC ;  941 Hz   */
7940
7941         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7942         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7943         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7944         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7945 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7946         /*                                       EC,1D,52,22 ;  1336 Hz   */
7947         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7948         /*                                       9B,3B,51,25 ;  1633 Hz   */
7949         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7950         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7951         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7952         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7953 }
7954
7955 static void DAA_Coeff_UK(IXJ *j)
7956 {
7957         int i;
7958
7959         j->daa_country = DAA_UK;
7960         /*----------------------------------------------- */
7961         /* CAO */
7962         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7963                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7964         }
7965
7966 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7967         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7968         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7969         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7970         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7971         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7972         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7973         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7974         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7975 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7976         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7977         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7982         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7984 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7985         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7986         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7987         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7988         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7989         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7990         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7991         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7992         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7993 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
7994         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7995         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8000         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8002 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8003         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8004         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8005         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8006         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8007 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8008         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8009         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8010         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8011         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8012 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8013         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8014         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8015         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8016         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8017         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8018         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8019         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8020         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8021 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8022         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8023         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8030 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8032         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8037         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8039 /* ; idle */
8040         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8041         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8042         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8043         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8044         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8045         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8046         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8047         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8048         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8049 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8050         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8051         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8056         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8058 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8059         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8060         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8061         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8062         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8063 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8064         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8065         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8066         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8067         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8068         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8069         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8070         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8071         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8072 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8073         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8074         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8079         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8081 /* ;CR Registers */
8082         /* Config. Reg. 0 (filters)        (cr0):FF */
8083         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8084 /* Config. Reg. 1 (dialing)        (cr1):05 */
8085         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8086 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8087         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8088 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8089         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8090 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8091         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8092         /* Config. Reg. 5 (Version)        (cr5):02 */
8093         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8094         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8095         /* ;xr Registers */
8096         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8097
8098         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8099         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8100
8101         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8102         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8103
8104         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8105 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8106         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8107 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8108         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8109 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8110         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8111 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8112         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8113 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8114         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8115         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8116         /*                                       12,33,5A,C3    ;  770 Hz   */
8117         /*                                       13,3C,5B,32    ;  852 Hz   */
8118         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8119
8120         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8121         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8122         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8123         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8124 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8125         /*                                       EC,1D,52,22    ;  1336 Hz   */
8126         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8127         /*                                       9B,3B,51,25    ;  1633 Hz   */
8128         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8129         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8130         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8131         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8132 }
8133
8134
8135 static void DAA_Coeff_France(IXJ *j)
8136 {
8137         int i;
8138
8139         j->daa_country = DAA_FRANCE;
8140         /*----------------------------------------------- */
8141         /* CAO */
8142         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8143                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8144         }
8145
8146 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8147         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8148         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8149         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8150         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8151         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8152         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8153         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8154         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8155 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8156         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8157         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8162         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8164 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8165         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8166         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8167         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8168         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8169         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8170         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8171         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8172         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8173 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8174         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8175         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8180         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8182 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8183         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8184         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8185         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8186         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8187 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8188         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8189         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8190         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8191         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8192 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8193         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8194         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8195         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8196         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8197         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8198         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8199         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8200         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8201 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8202         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8203         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8210 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8212         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8217         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8219 /* ; idle */
8220         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8221         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8222         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8223         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8224         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8225         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8226         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8227         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8228         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8229 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8230         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8231         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8236         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8238 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8239         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8240         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8241         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8242         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8243 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8244         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8245         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8246         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8247         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8248         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8249         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8250         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8251         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8252 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8253         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8254         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8259         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8261 /* ;CR Registers */
8262         /* Config. Reg. 0 (filters)        (cr0):FF */
8263         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8264 /* Config. Reg. 1 (dialing)        (cr1):05 */
8265         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8266 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8267         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8268 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8269         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8270 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8271         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8272         /* Config. Reg. 5 (Version)        (cr5):02 */
8273         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8274         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8275         /* ;xr Registers */
8276         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8277
8278         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8279         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8280
8281         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8282         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8283
8284         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8285 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8286         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8287 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8288         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8289 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8290         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8291 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8292         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8293 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8294         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8295         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8296         /*                                       12,33,5A,C3    ;  770 Hz   */
8297         /*                                       13,3C,5B,32    ;  852 Hz   */
8298         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8299
8300         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8301         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8302         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8303         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8304 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8305         /*                                       EC,1D,52,22    ;  1336 Hz   */
8306         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8307         /*                                       9B,3B,51,25    ;  1633 Hz   */
8308         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8309         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8310         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8311         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8312 }
8313
8314
8315 static void DAA_Coeff_Germany(IXJ *j)
8316 {
8317         int i;
8318
8319         j->daa_country = DAA_GERMANY;
8320         /*----------------------------------------------- */
8321         /* CAO */
8322         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8323                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8324         }
8325
8326 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8327         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8328         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8329         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8330         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8331         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8332         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8333         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8334         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8335 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8336         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8337         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8342         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8344 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8345         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8346         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8347         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8348         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8349         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8350         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8351         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8352         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8353 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8354         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8355         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8360         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8362 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8363         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8364         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8365         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8366         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8367 /* Bytes for AR-filter        (09): 72,42,13,4B */
8368         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8369         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8370         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8371         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8372 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8373         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8374         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8375         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8376         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8377         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8378         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8379         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8380         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8381 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8382         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8383         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8390 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8392         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8397         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8399 /* ;  (10K, 0.68uF) */
8400         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8401         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8402         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8403         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8404         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8405         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8406         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8407         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8408         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8409 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8410         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8411         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8416         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8418 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8419         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8420         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8421         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8422         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8423 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8424         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8425         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8426         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8427         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8428         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8429         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8430         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8431         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8432 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8433         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8434         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8439         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8441 /* ;CR Registers */
8442         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8443         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8444 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8445         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8446 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8447         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8448 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8449         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8450 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8451         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8452         /* Config. Reg. 5 (Version)        (cr5):02 */
8453         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8454         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8455         /* ;xr Registers */
8456         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8457
8458         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8459         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8460
8461         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8462         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8463
8464         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8465 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8466         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8467 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8468         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8469 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8470         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8471 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8472         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8473 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8474         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8475         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8476         /*                                       12,33,5A,C3    ;  770 Hz   */
8477         /*                                       13,3C,5B,32    ;  852 Hz   */
8478         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8479
8480         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8481         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8482         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8483         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8484 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8485         /*                                       EC,1D,52,22    ;  1336 Hz   */
8486         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8487         /*                                       9B,3B,51,25    ;  1633 Hz   */
8488         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8489         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8490         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8491         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8492 }
8493
8494
8495 static void DAA_Coeff_Australia(IXJ *j)
8496 {
8497         int i;
8498
8499         j->daa_country = DAA_AUSTRALIA;
8500         /*----------------------------------------------- */
8501         /* CAO */
8502         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8503                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8504         }
8505
8506 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8507         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8508         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8509         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8510         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8511         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8512         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8513         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8514         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8515 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8516         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8517         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8522         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8524 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8525         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8526         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8527         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8528         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8529         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8530         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8531         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8532         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8533 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8534         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8535         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8540         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8542 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8543         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8544         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8545         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8546         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8547 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8548         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8549         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8550         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8551         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8552 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8553         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8554         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8555         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8556         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8557         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8558         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8559         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8560         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8561 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8562         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8563         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8570 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8572         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8577         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8579 /* ;  idle */
8580         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8581         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8582         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8583         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8584         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8585         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8586         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8587         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8588         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8589 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8590         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8591         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8596         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8598 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8599         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8600         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8601         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8602         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8603 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8604         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8605         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8606         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8607         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8608         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8609         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8610         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8611         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8612 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8613         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8614         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8619         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8621 /* ;CR Registers */
8622         /* Config. Reg. 0 (filters)        (cr0):FF */
8623         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8624 /* Config. Reg. 1 (dialing)        (cr1):05 */
8625         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8626 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8627         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8628 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8629         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8630 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8631         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8632         /* Config. Reg. 5 (Version)        (cr5):02 */
8633         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8634         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8635         /* ;xr Registers */
8636         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8637
8638         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8639         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8640
8641         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8642         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8643
8644         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8645 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8646         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8647 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8648         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8649 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8650         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8651 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8652         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8653 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8654         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8655
8656         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8657         /*                                       12,33,5A,C3    ;  770 Hz   */
8658         /*                                       13,3C,5B,32    ;  852 Hz   */
8659         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8660         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8661         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8662         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8663         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8664
8665         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8666         /*                                       EC,1D,52,22    ;  1336 Hz   */
8667         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8668         /*                                       9B,3B,51,25    ;  1633 Hz   */
8669         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8670         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8671         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8672         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8673 }
8674
8675 static void DAA_Coeff_Japan(IXJ *j)
8676 {
8677         int i;
8678
8679         j->daa_country = DAA_JAPAN;
8680         /*----------------------------------------------- */
8681         /* CAO */
8682         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8683                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8684         }
8685
8686 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8687         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8688         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8689         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8690         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8691         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8692         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8693         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8694         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8695 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8696         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8697         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8702         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8704 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8705         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8706         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8707         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8708         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8709         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8710         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8711         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8712         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8713 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8714         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8715         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8720         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8722 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8723         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8724         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8725         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8726         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8727 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8728         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8729         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8730         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8731         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8732 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8733         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8734         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8735         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8736         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8737         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8738         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8739         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8740         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8741 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8742         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8743         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8750 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8752         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8757         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8759 /* ;  idle */
8760         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8761         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8762         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8763         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8764         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8765         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8766         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8767         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8768         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8769 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8770         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8771         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8776         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8778 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8779         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8780         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8781         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8782         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8783 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8784         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8785         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8786         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8787         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8788         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8789         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8790         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8791         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8792 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8793         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8794         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8799         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8801 /* ;CR Registers */
8802         /* Config. Reg. 0 (filters)        (cr0):FF */
8803         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8804 /* Config. Reg. 1 (dialing)        (cr1):05 */
8805         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8806 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8807         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8808 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8809         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8810 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8811         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8812         /* Config. Reg. 5 (Version)        (cr5):02 */
8813         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8814         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8815         /* ;xr Registers */
8816         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8817
8818         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8819         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8820
8821         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8822         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8823
8824         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8825 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8826         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8827 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8828         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8829 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8830         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8831 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8832         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8833 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8834         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8835         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8836         /*                                       12,33,5A,C3    ;  770 Hz   */
8837         /*                                       13,3C,5B,32    ;  852 Hz   */
8838         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8839
8840         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8841         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8842         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8843         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8844 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8845         /*                                       EC,1D,52,22    ;  1336 Hz   */
8846         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8847         /*                                       9B,3B,51,25    ;  1633 Hz   */
8848         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8849         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8850         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8851         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8852 }
8853
8854 static s16 tone_table[][19] =
8855 {
8856         {                       /* f20_50[] 11 */
8857                 32538,          /* A1 = 1.985962 */
8858                  -32325,        /* A2 = -0.986511 */
8859                  -343,          /* B2 = -0.010493 */
8860                  0,             /* B1 = 0 */
8861                  343,           /* B0 = 0.010493 */
8862                  32619,         /* A1 = 1.990906 */
8863                  -32520,        /* A2 = -0.992462 */
8864                  19179,         /* B2 = 0.585327 */
8865                  -19178,        /* B1 = -1.170593 */
8866                  19179,         /* B0 = 0.585327 */
8867                  32723,         /* A1 = 1.997314 */
8868                  -32686,        /* A2 = -0.997528 */
8869                  9973,          /* B2 = 0.304352 */
8870                  -9955,         /* B1 = -0.607605 */
8871                  9973,          /* B0 = 0.304352 */
8872                  7,             /* Internal filter scaling */
8873                  159,           /* Minimum in-band energy threshold */
8874                  21,            /* 21/32 in-band to broad-band ratio */
8875                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8876         },
8877         {                       /* f133_200[] 12 */
8878                 32072,          /* A1 = 1.95752 */
8879                  -31896,        /* A2 = -0.973419 */
8880                  -435,          /* B2 = -0.013294 */
8881                  0,             /* B1 = 0 */
8882                  435,           /* B0 = 0.013294 */
8883                  32188,         /* A1 = 1.9646 */
8884                  -32400,        /* A2 = -0.98877 */
8885                  15139,         /* B2 = 0.462036 */
8886                  -14882,        /* B1 = -0.908356 */
8887                  15139,         /* B0 = 0.462036 */
8888                  32473,         /* A1 = 1.981995 */
8889                  -32524,        /* A2 = -0.992584 */
8890                  23200,         /* B2 = 0.708008 */
8891                  -23113,        /* B1 = -1.410706 */
8892                  23200,         /* B0 = 0.708008 */
8893                  7,             /* Internal filter scaling */
8894                  159,           /* Minimum in-band energy threshold */
8895                  21,            /* 21/32 in-band to broad-band ratio */
8896                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8897         },
8898         {                       /* f300 13 */
8899                 31769,          /* A1 = -1.939026 */
8900                  -32584,        /* A2 = 0.994385 */
8901                  -475,          /* B2 = -0.014522 */
8902                  0,             /* B1 = 0.000000 */
8903                  475,           /* B0 = 0.014522 */
8904                  31789,         /* A1 = -1.940247 */
8905                  -32679,        /* A2 = 0.997284 */
8906                  17280,         /* B2 = 0.527344 */
8907                  -16865,        /* B1 = -1.029358 */
8908                  17280,         /* B0 = 0.527344 */
8909                  31841,         /* A1 = -1.943481 */
8910                  -32681,        /* A2 = 0.997345 */
8911                  543,           /* B2 = 0.016579 */
8912                  -525,          /* B1 = -0.032097 */
8913                  543,           /* B0 = 0.016579 */
8914                  5,             /* Internal filter scaling */
8915                  159,           /* Minimum in-band energy threshold */
8916                  21,            /* 21/32 in-band to broad-band ratio */
8917                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8918         },
8919         {                       /* f300_420[] 14 */
8920                 30750,          /* A1 = 1.876892 */
8921                  -31212,        /* A2 = -0.952515 */
8922                  -804,          /* B2 = -0.024541 */
8923                  0,             /* B1 = 0 */
8924                  804,           /* B0 = 0.024541 */
8925                  30686,         /* A1 = 1.872925 */
8926                  -32145,        /* A2 = -0.980988 */
8927                  14747,         /* B2 = 0.450043 */
8928                  -13703,        /* B1 = -0.836395 */
8929                  14747,         /* B0 = 0.450043 */
8930                  31651,         /* A1 = 1.931824 */
8931                  -32321,        /* A2 = -0.986389 */
8932                  24425,         /* B2 = 0.745422 */
8933                  -23914,        /* B1 = -1.459595 */
8934                  24427,         /* B0 = 0.745483 */
8935                  7,             /* Internal filter scaling */
8936                  159,           /* Minimum in-band energy threshold */
8937                  21,            /* 21/32 in-band to broad-band ratio */
8938                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8939         },
8940         {                       /* f330 15 */
8941                 31613,          /* A1 = -1.929565 */
8942                  -32646,        /* A2 = 0.996277 */
8943                  -185,          /* B2 = -0.005657 */
8944                  0,             /* B1 = 0.000000 */
8945                  185,           /* B0 = 0.005657 */
8946                  31620,         /* A1 = -1.929932 */
8947                  -32713,        /* A2 = 0.998352 */
8948                  19253,         /* B2 = 0.587585 */
8949                  -18566,        /* B1 = -1.133179 */
8950                  19253,         /* B0 = 0.587585 */
8951                  31674,         /* A1 = -1.933228 */
8952                  -32715,        /* A2 = 0.998413 */
8953                  2575,          /* B2 = 0.078590 */
8954                  -2495,         /* B1 = -0.152283 */
8955                  2575,          /* B0 = 0.078590 */
8956                  5,             /* Internal filter scaling */
8957                  159,           /* Minimum in-band energy threshold */
8958                  21,            /* 21/32 in-band to broad-band ratio */
8959                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8960         },
8961         {                       /* f300_425[] 16 */
8962                 30741,          /* A1 = 1.876282 */
8963                  -31475,        /* A2 = -0.960541 */
8964                  -703,          /* B2 = -0.021484 */
8965                  0,             /* B1 = 0 */
8966                  703,           /* B0 = 0.021484 */
8967                  30688,         /* A1 = 1.873047 */
8968                  -32248,        /* A2 = -0.984161 */
8969                  14542,         /* B2 = 0.443787 */
8970                  -13523,        /* B1 = -0.825439 */
8971                  14542,         /* B0 = 0.443817 */
8972                  31494,         /* A1 = 1.922302 */
8973                  -32366,        /* A2 = -0.987762 */
8974                  21577,         /* B2 = 0.658508 */
8975                  -21013,        /* B1 = -1.282532 */
8976                  21577,         /* B0 = 0.658508 */
8977                  7,             /* Internal filter scaling */
8978                  159,           /* Minimum in-band energy threshold */
8979                  21,            /* 21/32 in-band to broad-band ratio */
8980                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8981         },
8982         {                       /* f330_440[] 17 */
8983                 30627,          /* A1 = 1.869324 */
8984                  -31338,        /* A2 = -0.95636 */
8985                  -843,          /* B2 = -0.025749 */
8986                  0,             /* B1 = 0 */
8987                  843,           /* B0 = 0.025749 */
8988                  30550,         /* A1 = 1.864685 */
8989                  -32221,        /* A2 = -0.983337 */
8990                  13594,         /* B2 = 0.414886 */
8991                  -12589,        /* B1 = -0.768402 */
8992                  13594,         /* B0 = 0.414886 */
8993                  31488,         /* A1 = 1.921936 */
8994                  -32358,        /* A2 = -0.987518 */
8995                  24684,         /* B2 = 0.753296 */
8996                  -24029,        /* B1 = -1.466614 */
8997                  24684,         /* B0 = 0.753296 */
8998                  7,             /* Internal filter scaling */
8999                  159,           /* Minimum in-band energy threshold */
9000                  21,            /* 21/32 in-band to broad-band ratio */
9001                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9002         },
9003         {                       /* f340 18 */
9004                 31546,          /* A1 = -1.925476 */
9005                  -32646,        /* A2 = 0.996277 */
9006                  -445,          /* B2 = -0.013588 */
9007                  0,             /* B1 = 0.000000 */
9008                  445,           /* B0 = 0.013588 */
9009                  31551,         /* A1 = -1.925781 */
9010                  -32713,        /* A2 = 0.998352 */
9011                  23884,         /* B2 = 0.728882 */
9012                  -22979,        /* B1 = -1.402527 */
9013                  23884,         /* B0 = 0.728882 */
9014                  31606,         /* A1 = -1.929138 */
9015                  -32715,        /* A2 = 0.998413 */
9016                  863,           /* B2 = 0.026367 */
9017                  -835,          /* B1 = -0.050985 */
9018                  863,           /* B0 = 0.026367 */
9019                  5,             /* Internal filter scaling */
9020                  159,           /* Minimum in-band energy threshold */
9021                  21,            /* 21/32 in-band to broad-band ratio */
9022                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9023         },
9024         {                       /* f350_400[] 19 */
9025                 31006,          /* A1 = 1.892517 */
9026                  -32029,        /* A2 = -0.977448 */
9027                  -461,          /* B2 = -0.014096 */
9028                  0,             /* B1 = 0 */
9029                  461,           /* B0 = 0.014096 */
9030                  30999,         /* A1 = 1.892029 */
9031                  -32487,        /* A2 = -0.991455 */
9032                  11325,         /* B2 = 0.345612 */
9033                  -10682,        /* B1 = -0.651978 */
9034                  11325,         /* B0 = 0.345612 */
9035                  31441,         /* A1 = 1.919067 */
9036                  -32526,        /* A2 = -0.992615 */
9037                  24324,         /* B2 = 0.74231 */
9038                  -23535,        /* B1 = -1.436523 */
9039                  24324,         /* B0 = 0.74231 */
9040                  7,             /* Internal filter scaling */
9041                  159,           /* Minimum in-band energy threshold */
9042                  21,            /* 21/32 in-band to broad-band ratio */
9043                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9044         },
9045         {                       /* f350_440[] */
9046                 30634,          /* A1 = 1.869751 */
9047                  -31533,        /* A2 = -0.962341 */
9048                  -680,          /* B2 = -0.020782 */
9049                  0,             /* B1 = 0 */
9050                  680,           /* B0 = 0.020782 */
9051                  30571,         /* A1 = 1.865906 */
9052                  -32277,        /* A2 = -0.985016 */
9053                  12894,         /* B2 = 0.393524 */
9054                  -11945,        /* B1 = -0.729065 */
9055                  12894,         /* B0 = 0.393524 */
9056                  31367,         /* A1 = 1.91449 */
9057                  -32379,        /* A2 = -0.988129 */
9058                  23820,         /* B2 = 0.726929 */
9059                  -23104,        /* B1 = -1.410217 */
9060                  23820,         /* B0 = 0.726929 */
9061                  7,             /* Internal filter scaling */
9062                  159,           /* Minimum in-band energy threshold */
9063                  21,            /* 21/32 in-band to broad-band ratio */
9064                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9065         },
9066         {                       /* f350_450[] */
9067                 30552,          /* A1 = 1.864807 */
9068                  -31434,        /* A2 = -0.95929 */
9069                  -690,          /* B2 = -0.021066 */
9070                  0,             /* B1 = 0 */
9071                  690,           /* B0 = 0.021066 */
9072                  30472,         /* A1 = 1.859924 */
9073                  -32248,        /* A2 = -0.984161 */
9074                  13385,         /* B2 = 0.408478 */
9075                  -12357,        /* B1 = -0.754242 */
9076                  13385,         /* B0 = 0.408478 */
9077                  31358,         /* A1 = 1.914001 */
9078                  -32366,        /* A2 = -0.987732 */
9079                  26488,         /* B2 = 0.80835 */
9080                  -25692,        /* B1 = -1.568176 */
9081                  26490,         /* B0 = 0.808411 */
9082                  7,             /* Internal filter scaling */
9083                  159,           /* Minimum in-band energy threshold */
9084                  21,            /* 21/32 in-band to broad-band ratio */
9085                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9086         },
9087         {                       /* f360 */
9088                 31397,          /* A1 = -1.916321 */
9089                  -32623,        /* A2 = 0.995605 */
9090                  -117,          /* B2 = -0.003598 */
9091                  0,             /* B1 = 0.000000 */
9092                  117,           /* B0 = 0.003598 */
9093                  31403,         /* A1 = -1.916687 */
9094                  -32700,        /* A2 = 0.997925 */
9095                  3388,          /* B2 = 0.103401 */
9096                  -3240,         /* B1 = -0.197784 */
9097                  3388,          /* B0 = 0.103401 */
9098                  31463,         /* A1 = -1.920410 */
9099                  -32702,        /* A2 = 0.997986 */
9100                  13346,         /* B2 = 0.407288 */
9101                  -12863,        /* B1 = -0.785126 */
9102                  13346,         /* B0 = 0.407288 */
9103                  5,             /* Internal filter scaling */
9104                  159,           /* Minimum in-band energy threshold */
9105                  21,            /* 21/32 in-band to broad-band ratio */
9106                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9107         },
9108         {                       /* f380_420[] */
9109                 30831,          /* A1 = 1.881775 */
9110                  -32064,        /* A2 = -0.978546 */
9111                  -367,          /* B2 = -0.01122 */
9112                  0,             /* B1 = 0 */
9113                  367,           /* B0 = 0.01122 */
9114                  30813,         /* A1 = 1.880737 */
9115                  -32456,        /* A2 = -0.990509 */
9116                  11068,         /* B2 = 0.337769 */
9117                  -10338,        /* B1 = -0.631042 */
9118                  11068,         /* B0 = 0.337769 */
9119                  31214,         /* A1 = 1.905212 */
9120                  -32491,        /* A2 = -0.991577 */
9121                  16374,         /* B2 = 0.499695 */
9122                  -15781,        /* B1 = -0.963196 */
9123                  16374,         /* B0 = 0.499695 */
9124                  7,             /* Internal filter scaling */
9125                  159,           /* Minimum in-band energy threshold */
9126                  21,            /* 21/32 in-band to broad-band ratio */
9127                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9128         },
9129         {                       /* f392 */
9130                 31152,          /* A1 = -1.901428 */
9131                  -32613,        /* A2 = 0.995300 */
9132                  -314,          /* B2 = -0.009605 */
9133                  0,             /* B1 = 0.000000 */
9134                  314,           /* B0 = 0.009605 */
9135                  31156,         /* A1 = -1.901672 */
9136                  -32694,        /* A2 = 0.997742 */
9137                  28847,         /* B2 = 0.880371 */
9138                  -2734,         /* B1 = -0.166901 */
9139                  28847,         /* B0 = 0.880371 */
9140                  31225,         /* A1 = -1.905823 */
9141                  -32696,        /* A2 = 0.997803 */
9142                  462,           /* B2 = 0.014108 */
9143                  -442,          /* B1 = -0.027019 */
9144                  462,           /* B0 = 0.014108 */
9145                  5,             /* Internal filter scaling */
9146                  159,           /* Minimum in-band energy threshold */
9147                  21,            /* 21/32 in-band to broad-band ratio */
9148                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9149         },
9150         {                       /* f400_425[] */
9151                 30836,          /* A1 = 1.882141 */
9152                  -32296,        /* A2 = -0.985596 */
9153                  -324,          /* B2 = -0.009903 */
9154                  0,             /* B1 = 0 */
9155                  324,           /* B0 = 0.009903 */
9156                  30825,         /* A1 = 1.881409 */
9157                  -32570,        /* A2 = -0.993958 */
9158                  16847,         /* B2 = 0.51416 */
9159                  -15792,        /* B1 = -0.963898 */
9160                  16847,         /* B0 = 0.51416 */
9161                  31106,         /* A1 = 1.89856 */
9162                  -32584,        /* A2 = -0.994415 */
9163                  9579,          /* B2 = 0.292328 */
9164                  -9164,         /* B1 = -0.559357 */
9165                  9579,          /* B0 = 0.292328 */
9166                  7,             /* Internal filter scaling */
9167                  159,           /* Minimum in-band energy threshold */
9168                  21,            /* 21/32 in-band to broad-band ratio */
9169                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9170         },
9171         {                       /* f400_440[] */
9172                 30702,          /* A1 = 1.873962 */
9173                  -32134,        /* A2 = -0.980682 */
9174                  -517,          /* B2 = -0.015793 */
9175                  0,             /* B1 = 0 */
9176                  517,           /* B0 = 0.015793 */
9177                  30676,         /* A1 = 1.872375 */
9178                  -32520,        /* A2 = -0.992462 */
9179                  8144,          /* B2 = 0.24855 */
9180                  -7596,         /* B1 = -0.463684 */
9181                  8144,          /* B0 = 0.24855 */
9182                  31084,         /* A1 = 1.897217 */
9183                  -32547,        /* A2 = -0.993256 */
9184                  22713,         /* B2 = 0.693176 */
9185                  -21734,        /* B1 = -1.326599 */
9186                  22713,         /* B0 = 0.693176 */
9187                  7,             /* Internal filter scaling */
9188                  159,           /* Minimum in-band energy threshold */
9189                  21,            /* 21/32 in-band to broad-band ratio */
9190                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9191         },
9192         {                       /* f400_450[] */
9193                 30613,          /* A1 = 1.86853 */
9194                  -32031,        /* A2 = -0.977509 */
9195                  -618,          /* B2 = -0.018866 */
9196                  0,             /* B1 = 0 */
9197                  618,           /* B0 = 0.018866 */
9198                  30577,         /* A1 = 1.866272 */
9199                  -32491,        /* A2 = -0.991577 */
9200                  9612,          /* B2 = 0.293335 */
9201                  -8935,         /* B1 = -0.54541 */
9202                  9612,          /* B0 = 0.293335 */
9203                  31071,         /* A1 = 1.896484 */
9204                  -32524,        /* A2 = -0.992584 */
9205                  21596,         /* B2 = 0.659058 */
9206                  -20667,        /* B1 = -1.261414 */
9207                  21596,         /* B0 = 0.659058 */
9208                  7,             /* Internal filter scaling */
9209                  159,           /* Minimum in-band energy threshold */
9210                  21,            /* 21/32 in-band to broad-band ratio */
9211                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9212         },
9213         {                       /* f420 */
9214                 30914,          /* A1 = -1.886841 */
9215                  -32584,        /* A2 = 0.994385 */
9216                  -426,          /* B2 = -0.013020 */
9217                  0,             /* B1 = 0.000000 */
9218                  426,           /* B0 = 0.013020 */
9219                  30914,         /* A1 = -1.886841 */
9220                  -32679,        /* A2 = 0.997314 */
9221                  17520,         /* B2 = 0.534668 */
9222                  -16471,        /* B1 = -1.005310 */
9223                  17520,         /* B0 = 0.534668 */
9224                  31004,         /* A1 = -1.892334 */
9225                  -32683,        /* A2 = 0.997406 */
9226                  819,           /* B2 = 0.025023 */
9227                  -780,          /* B1 = -0.047619 */
9228                  819,           /* B0 = 0.025023 */
9229                  5,             /* Internal filter scaling */
9230                  159,           /* Minimum in-band energy threshold */
9231                  21,            /* 21/32 in-band to broad-band ratio */
9232                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9233         },
9234 #if 0
9235         {                       /* f425 */
9236                 30881,          /* A1 = -1.884827 */
9237                  -32603,        /* A2 = 0.994965 */
9238                  -496,          /* B2 = -0.015144 */
9239                  0,             /* B1 = 0.000000 */
9240                  496,           /* B0 = 0.015144 */
9241                  30880,         /* A1 = -1.884766 */
9242                  -32692,        /* A2 = 0.997711 */
9243                  24767,         /* B2 = 0.755859 */
9244                  -23290,        /* B1 = -1.421509 */
9245                  24767,         /* B0 = 0.755859 */
9246                  30967,         /* A1 = -1.890076 */
9247                  -32694,        /* A2 = 0.997772 */
9248                  728,           /* B2 = 0.022232 */
9249                  -691,          /* B1 = -0.042194 */
9250                  728,           /* B0 = 0.022232 */
9251                  5,             /* Internal filter scaling */
9252                  159,           /* Minimum in-band energy threshold */
9253                  21,            /* 21/32 in-band to broad-band ratio */
9254                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9255         },
9256 #else
9257         {
9258                 30850,
9259                 -32534,
9260                 -504,
9261                 0,
9262                 504,
9263                 30831,
9264                 -32669,
9265                 24303,
9266                 -22080,
9267                 24303,
9268                 30994,
9269                 -32673,
9270                 1905,
9271                 -1811,
9272                 1905,
9273                 5,
9274                 129,
9275                 17,
9276                 0xff5
9277         },
9278 #endif
9279         {                       /* f425_450[] */
9280                 30646,          /* A1 = 1.870544 */
9281                  -32327,        /* A2 = -0.986572 */
9282                  -287,          /* B2 = -0.008769 */
9283                  0,             /* B1 = 0 */
9284                  287,           /* B0 = 0.008769 */
9285                  30627,         /* A1 = 1.869324 */
9286                  -32607,        /* A2 = -0.995087 */
9287                  13269,         /* B2 = 0.404968 */
9288                  -12376,        /* B1 = -0.755432 */
9289                  13269,         /* B0 = 0.404968 */
9290                  30924,         /* A1 = 1.887512 */
9291                  -32619,        /* A2 = -0.995453 */
9292                  19950,         /* B2 = 0.608826 */
9293                  -18940,        /* B1 = -1.156006 */
9294                  19950,         /* B0 = 0.608826 */
9295                  7,             /* Internal filter scaling */
9296                  159,           /* Minimum in-band energy threshold */
9297                  21,            /* 21/32 in-band to broad-band ratio */
9298                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9299         },
9300         {                       /* f425_475[] */
9301                 30396,          /* A1 = 1.855225 */
9302                  -32014,        /* A2 = -0.97699 */
9303                  -395,          /* B2 = -0.012055 */
9304                  0,             /* B1 = 0 */
9305                  395,           /* B0 = 0.012055 */
9306                  30343,         /* A1 = 1.85199 */
9307                  -32482,        /* A2 = -0.991302 */
9308                  17823,         /* B2 = 0.543945 */
9309                  -16431,        /* B1 = -1.002869 */
9310                  17823,         /* B0 = 0.543945 */
9311                  30872,         /* A1 = 1.884338 */
9312                  -32516,        /* A2 = -0.99231 */
9313                  18124,         /* B2 = 0.553101 */
9314                  -17246,        /* B1 = -1.052673 */
9315                  18124,         /* B0 = 0.553101 */
9316                  7,             /* Internal filter scaling */
9317                  159,           /* Minimum in-band energy threshold */
9318                  21,            /* 21/32 in-band to broad-band ratio */
9319                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9320         },
9321         {                       /* f435 */
9322                 30796,          /* A1 = -1.879639 */
9323                  -32603,        /* A2 = 0.994965 */
9324                  -254,          /* B2 = -0.007762 */
9325                  0,             /* B1 = 0.000000 */
9326                  254,           /* B0 = 0.007762 */
9327                  30793,         /* A1 = -1.879456 */
9328                  -32692,        /* A2 = 0.997711 */
9329                  18934,         /* B2 = 0.577820 */
9330                  -17751,        /* B1 = -1.083496 */
9331                  18934,         /* B0 = 0.577820 */
9332                  30882,         /* A1 = -1.884888 */
9333                  -32694,        /* A2 = 0.997772 */
9334                  1858,          /* B2 = 0.056713 */
9335                  -1758,         /* B1 = -0.107357 */
9336                  1858,          /* B0 = 0.056713 */
9337                  5,             /* Internal filter scaling */
9338                  159,           /* Minimum in-band energy threshold */
9339                  21,            /* 21/32 in-band to broad-band ratio */
9340                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9341         },
9342         {                       /* f440_450[] */
9343                 30641,          /* A1 = 1.870239 */
9344                  -32458,        /* A2 = -0.99057 */
9345                  -155,          /* B2 = -0.004735 */
9346                  0,             /* B1 = 0 */
9347                  155,           /* B0 = 0.004735 */
9348                  30631,         /* A1 = 1.869568 */
9349                  -32630,        /* A2 = -0.995789 */
9350                  11453,         /* B2 = 0.349548 */
9351                  -10666,        /* B1 = -0.651001 */
9352                  11453,         /* B0 = 0.349548 */
9353                  30810,         /* A1 = 1.880554 */
9354                  -32634,        /* A2 = -0.995941 */
9355                  12237,         /* B2 = 0.373474 */
9356                  -11588,        /* B1 = -0.707336 */
9357                  12237,         /* B0 = 0.373474 */
9358                  7,             /* Internal filter scaling */
9359                  159,           /* Minimum in-band energy threshold */
9360                  21,            /* 21/32 in-band to broad-band ratio */
9361                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9362         },
9363         {                       /* f440_480[] */
9364                 30367,          /* A1 = 1.853455 */
9365                  -32147,        /* A2 = -0.981079 */
9366                  -495,          /* B2 = -0.015113 */
9367                  0,             /* B1 = 0 */
9368                  495,           /* B0 = 0.015113 */
9369                  30322,         /* A1 = 1.850769 */
9370                  -32543,        /* A2 = -0.993134 */
9371                  10031,         /* B2 = 0.306152 */
9372                  -9252,         /* B1 = -0.564728 */
9373                  10031,         /* B0 = 0.306152 */
9374                  30770,         /* A1 = 1.878052 */
9375                  -32563,        /* A2 = -0.993774 */
9376                  22674,         /* B2 = 0.691956 */
9377                  -21465,        /* B1 = -1.31012 */
9378                  22674,         /* B0 = 0.691956 */
9379                  7,             /* Internal filter scaling */
9380                  159,           /* Minimum in-band energy threshold */
9381                  21,            /* 21/32 in-band to broad-band ratio */
9382                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9383         },
9384         {                       /* f445 */
9385                 30709,          /* A1 = -1.874329 */
9386                  -32603,        /* A2 = 0.994965 */
9387                  -83,           /* B2 = -0.002545 */
9388                  0,             /* B1 = 0.000000 */
9389                  83,            /* B0 = 0.002545 */
9390                  30704,         /* A1 = -1.874084 */
9391                  -32692,        /* A2 = 0.997711 */
9392                  10641,         /* B2 = 0.324738 */
9393                  -9947,         /* B1 = -0.607147 */
9394                  10641,         /* B0 = 0.324738 */
9395                  30796,         /* A1 = -1.879639 */
9396                  -32694,        /* A2 = 0.997772 */
9397                  10079,         /* B2 = 0.307587 */
9398                  9513,          /* B1 = 0.580688 */
9399                  10079,         /* B0 = 0.307587 */
9400                  5,             /* Internal filter scaling */
9401                  159,           /* Minimum in-band energy threshold */
9402                  21,            /* 21/32 in-band to broad-band ratio */
9403                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9404         },
9405         {                       /* f450 */
9406                 30664,          /* A1 = -1.871643 */
9407                  -32603,        /* A2 = 0.994965 */
9408                  -164,          /* B2 = -0.005029 */
9409                  0,             /* B1 = 0.000000 */
9410                  164,           /* B0 = 0.005029 */
9411                  30661,         /* A1 = -1.871399 */
9412                  -32692,        /* A2 = 0.997711 */
9413                  15294,         /* B2 = 0.466736 */
9414                  -14275,        /* B1 = -0.871307 */
9415                  15294,         /* B0 = 0.466736 */
9416                  30751,         /* A1 = -1.876953 */
9417                  -32694,        /* A2 = 0.997772 */
9418                  3548,          /* B2 = 0.108284 */
9419                  -3344,         /* B1 = -0.204155 */
9420                  3548,          /* B0 = 0.108284 */
9421                  5,             /* Internal filter scaling */
9422                  159,           /* Minimum in-band energy threshold */
9423                  21,            /* 21/32 in-band to broad-band ratio */
9424                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9425         },
9426         {                       /* f452 */
9427                 30653,          /* A1 = -1.870911 */
9428                  -32615,        /* A2 = 0.995361 */
9429                  -209,          /* B2 = -0.006382 */
9430                  0,             /* B1 = 0.000000 */
9431                  209,           /* B0 = 0.006382 */
9432                  30647,         /* A1 = -1.870605 */
9433                  -32702,        /* A2 = 0.997986 */
9434                  18971,         /* B2 = 0.578979 */
9435                  -17716,        /* B1 = -1.081299 */
9436                  18971,         /* B0 = 0.578979 */
9437                  30738,         /* A1 = -1.876099 */
9438                  -32702,        /* A2 = 0.998016 */
9439                  2967,          /* B2 = 0.090561 */
9440                  -2793,         /* B1 = -0.170502 */
9441                  2967,          /* B0 = 0.090561 */
9442                  5,             /* Internal filter scaling */
9443                  159,           /* Minimum in-band energy threshold */
9444                  21,            /* 21/32 in-band to broad-band ratio */
9445                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9446         },
9447         {                       /* f475 */
9448                 30437,          /* A1 = -1.857727 */
9449                  -32603,        /* A2 = 0.994965 */
9450                  -264,          /* B2 = -0.008062 */
9451                  0,             /* B1 = 0.000000 */
9452                  264,           /* B0 = 0.008062 */
9453                  30430,         /* A1 = -1.857300 */
9454                  -32692,        /* A2 = 0.997711 */
9455                  21681,         /* B2 = 0.661682 */
9456                  -20082,        /* B1 = -1.225708 */
9457                  21681,         /* B0 = 0.661682 */
9458                  30526,         /* A1 = -1.863220 */
9459                  -32694,        /* A2 = 0.997742 */
9460                  1559,          /* B2 = 0.047600 */
9461                  -1459,         /* B1 = -0.089096 */
9462                  1559,          /* B0 = 0.047600 */
9463                  5,             /* Internal filter scaling */
9464                  159,           /* Minimum in-band energy threshold */
9465                  21,            /* 21/32 in-band to broad-band ratio */
9466                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9467         },
9468         {                       /* f480_620[] */
9469                 28975,          /* A1 = 1.768494 */
9470                  -30955,        /* A2 = -0.944672 */
9471                  -1026,         /* B2 = -0.03133 */
9472                  0,             /* B1 = 0 */
9473                  1026,          /* B0 = 0.03133 */
9474                  28613,         /* A1 = 1.746399 */
9475                  -32089,        /* A2 = -0.979309 */
9476                  14214,         /* B2 = 0.433807 */
9477                  -12202,        /* B1 = -0.744812 */
9478                  14214,         /* B0 = 0.433807 */
9479                  30243,         /* A1 = 1.845947 */
9480                  -32238,        /* A2 = -0.983856 */
9481                  24825,         /* B2 = 0.757629 */
9482                  -23402,        /* B1 = -1.428345 */
9483                  24825,         /* B0 = 0.757629 */
9484                  7,             /* Internal filter scaling */
9485                  159,           /* Minimum in-band energy threshold */
9486                  21,            /* 21/32 in-band to broad-band ratio */
9487                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9488         },
9489         {                       /* f494 */
9490                 30257,          /* A1 = -1.846741 */
9491                  -32605,        /* A2 = 0.995056 */
9492                  -249,          /* B2 = -0.007625 */
9493                  0,             /* B1 = 0.000000 */
9494                  249,           /* B0 = 0.007625 */
9495                  30247,         /* A1 = -1.846191 */
9496                  -32694,        /* A2 = 0.997772 */
9497                  18088,         /* B2 = 0.552002 */
9498                  -16652,        /* B1 = -1.016418 */
9499                  18088,         /* B0 = 0.552002 */
9500                  30348,         /* A1 = -1.852295 */
9501                  -32696,        /* A2 = 0.997803 */
9502                  2099,          /* B2 = 0.064064 */
9503                  -1953,         /* B1 = -0.119202 */
9504                  2099,          /* B0 = 0.064064 */
9505                  5,             /* Internal filter scaling */
9506                  159,           /* Minimum in-band energy threshold */
9507                  21,            /* 21/32 in-band to broad-band ratio */
9508                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9509         },
9510         {                       /* f500 */
9511                 30202,          /* A1 = -1.843431 */
9512                  -32624,        /* A2 = 0.995622 */
9513                  -413,          /* B2 = -0.012622 */
9514                  0,             /* B1 = 0.000000 */
9515                  413,           /* B0 = 0.012622 */
9516                  30191,         /* A1 = -1.842721 */
9517                  -32714,        /* A2 = 0.998364 */
9518                  25954,         /* B2 = 0.792057 */
9519                  -23890,        /* B1 = -1.458131 */
9520                  25954,         /* B0 = 0.792057 */
9521                  30296,         /* A1 = -1.849172 */
9522                  -32715,        /* A2 = 0.998397 */
9523                  2007,          /* B2 = 0.061264 */
9524                  -1860,         /* B1 = -0.113568 */
9525                  2007,          /* B0 = 0.061264 */
9526                  5,             /* Internal filter scaling */
9527                  159,           /* Minimum in-band energy threshold */
9528                  21,            /* 21/32 in-band to broad-band ratio */
9529                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9530         },
9531         {                       /* f520 */
9532                 30001,          /* A1 = -1.831116 */
9533                  -32613,        /* A2 = 0.995270 */
9534                  -155,          /* B2 = -0.004750 */
9535                  0,             /* B1 = 0.000000 */
9536                  155,           /* B0 = 0.004750 */
9537                  29985,         /* A1 = -1.830200 */
9538                  -32710,        /* A2 = 0.998260 */
9539                  6584,          /* B2 = 0.200928 */
9540                  -6018,         /* B1 = -0.367355 */
9541                  6584,          /* B0 = 0.200928 */
9542                  30105,         /* A1 = -1.837524 */
9543                  -32712,        /* A2 = 0.998291 */
9544                  23812,         /* B2 = 0.726685 */
9545                  -21936,        /* B1 = -1.338928 */
9546                  23812,         /* B0 = 0.726685 */
9547                  5,             /* Internal filter scaling */
9548                  159,           /* Minimum in-band energy threshold */
9549                  21,            /* 21/32 in-band to broad-band ratio */
9550                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9551         },
9552         {                       /* f523 */
9553                 29964,          /* A1 = -1.828918 */
9554                  -32601,        /* A2 = 0.994904 */
9555                  -101,          /* B2 = -0.003110 */
9556                  0,             /* B1 = 0.000000 */
9557                  101,           /* B0 = 0.003110 */
9558                  29949,         /* A1 = -1.827942 */
9559                  -32700,        /* A2 = 0.997925 */
9560                  11041,         /* B2 = 0.336975 */
9561                  -10075,        /* B1 = -0.614960 */
9562                  11041,         /* B0 = 0.336975 */
9563                  30070,         /* A1 = -1.835388 */
9564                  -32702,        /* A2 = 0.997986 */
9565                  16762,         /* B2 = 0.511536 */
9566                  -15437,        /* B1 = -0.942230 */
9567                  16762,         /* B0 = 0.511536 */
9568                  5,             /* Internal filter scaling */
9569                  159,           /* Minimum in-band energy threshold */
9570                  21,            /* 21/32 in-band to broad-band ratio */
9571                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9572         },
9573         {                       /* f525 */
9574                 29936,          /* A1 = -1.827209 */
9575                  -32584,        /* A2 = 0.994415 */
9576                  -91,           /* B2 = -0.002806 */
9577                  0,             /* B1 = 0.000000 */
9578                  91,            /* B0 = 0.002806 */
9579                  29921,         /* A1 = -1.826233 */
9580                  -32688,        /* A2 = 0.997559 */
9581                  11449,         /* B2 = 0.349396 */
9582                  -10426,        /* B1 = -0.636383 */
9583                  11449,         /* B0 = 0.349396 */
9584                  30045,         /* A1 = -1.833862 */
9585                  -32688,        /* A2 = 0.997589 */
9586                  13055,         /* B2 = 0.398407 */
9587                  -12028,        /* B1 = -0.734161 */
9588                  13055,         /* B0 = 0.398407 */
9589                  5,             /* Internal filter scaling */
9590                  159,           /* Minimum in-band energy threshold */
9591                  21,            /* 21/32 in-band to broad-band ratio */
9592                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9593         },
9594         {                       /* f540_660[] */
9595                 28499,          /* A1 = 1.739441 */
9596                  -31129,        /* A2 = -0.949982 */
9597                  -849,          /* B2 = -0.025922 */
9598                  0,             /* B1 = 0 */
9599                  849,           /* B0 = 0.025922 */
9600                  28128,         /* A1 = 1.716797 */
9601                  -32130,        /* A2 = -0.98056 */
9602                  14556,         /* B2 = 0.444214 */
9603                  -12251,        /* B1 = -0.747772 */
9604                  14556,         /* B0 = 0.444244 */
9605                  29667,         /* A1 = 1.81073 */
9606                  -32244,        /* A2 = -0.984039 */
9607                  23038,         /* B2 = 0.703064 */
9608                  -21358,        /* B1 = -1.303589 */
9609                  23040,         /* B0 = 0.703125 */
9610                  7,             /* Internal filter scaling */
9611                  159,           /* Minimum in-band energy threshold */
9612                  21,            /* 21/32 in-band to broad-band ratio */
9613                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9614         },
9615         {                       /* f587 */
9616                 29271,          /* A1 = -1.786560 */
9617                  -32599,        /* A2 = 0.994873 */
9618                  -490,          /* B2 = -0.014957 */
9619                  0,             /* B1 = 0.000000 */
9620                  490,           /* B0 = 0.014957 */
9621                  29246,         /* A1 = -1.785095 */
9622                  -32700,        /* A2 = 0.997925 */
9623                  28961,         /* B2 = 0.883850 */
9624                  -25796,        /* B1 = -1.574463 */
9625                  28961,         /* B0 = 0.883850 */
9626                  29383,         /* A1 = -1.793396 */
9627                  -32700,        /* A2 = 0.997955 */
9628                  1299,          /* B2 = 0.039650 */
9629                  -1169,         /* B1 = -0.071396 */
9630                  1299,          /* B0 = 0.039650 */
9631                  5,             /* Internal filter scaling */
9632                  159,           /* Minimum in-band energy threshold */
9633                  21,            /* 21/32 in-band to broad-band ratio */
9634                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9635         },
9636         {                       /* f590 */
9637                 29230,          /* A1 = -1.784058 */
9638                  -32584,        /* A2 = 0.994415 */
9639                  -418,          /* B2 = -0.012757 */
9640                  0,             /* B1 = 0.000000 */
9641                  418,           /* B0 = 0.012757 */
9642                  29206,         /* A1 = -1.782593 */
9643                  -32688,        /* A2 = 0.997559 */
9644                  36556,         /* B2 = 1.115601 */
9645                  -32478,        /* B1 = -1.982300 */
9646                  36556,         /* B0 = 1.115601 */
9647                  29345,         /* A1 = -1.791077 */
9648                  -32688,        /* A2 = 0.997589 */
9649                  897,           /* B2 = 0.027397 */
9650                  -808,          /* B1 = -0.049334 */
9651                  897,           /* B0 = 0.027397 */
9652                  5,             /* Internal filter scaling */
9653                  159,           /* Minimum in-band energy threshold */
9654                  21,            /* 21/32 in-band to broad-band ratio */
9655                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9656         },
9657         {                       /* f600 */
9658                 29116,          /* A1 = -1.777100 */
9659                  -32603,        /* A2 = 0.994965 */
9660                  -165,          /* B2 = -0.005039 */
9661                  0,             /* B1 = 0.000000 */
9662                  165,           /* B0 = 0.005039 */
9663                  29089,         /* A1 = -1.775452 */
9664                  -32708,        /* A2 = 0.998199 */
9665                  6963,          /* B2 = 0.212494 */
9666                  -6172,         /* B1 = -0.376770 */
9667                  6963,          /* B0 = 0.212494 */
9668                  29237,         /* A1 = -1.784485 */
9669                  -32710,        /* A2 = 0.998230 */
9670                  24197,         /* B2 = 0.738464 */
9671                  -21657,        /* B1 = -1.321899 */
9672                  24197,         /* B0 = 0.738464 */
9673                  5,             /* Internal filter scaling */
9674                  159,           /* Minimum in-band energy threshold */
9675                  21,            /* 21/32 in-band to broad-band ratio */
9676                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9677         },
9678         {                       /* f660 */
9679                 28376,          /* A1 = -1.731934 */
9680                  -32567,        /* A2 = 0.993896 */
9681                  -363,          /* B2 = -0.011102 */
9682                  0,             /* B1 = 0.000000 */
9683                  363,           /* B0 = 0.011102 */
9684                  28337,         /* A1 = -1.729614 */
9685                  -32683,        /* A2 = 0.997434 */
9686                  21766,         /* B2 = 0.664246 */
9687                  -18761,        /* B1 = -1.145081 */
9688                  21766,         /* B0 = 0.664246 */
9689                  28513,         /* A1 = -1.740356 */
9690                  -32686,        /* A2 = 0.997498 */
9691                  2509,          /* B2 = 0.076584 */
9692                  -2196,         /* B1 = -0.134041 */
9693                  2509,          /* B0 = 0.076584 */
9694                  5,             /* Internal filter scaling */
9695                  159,           /* Minimum in-band energy threshold */
9696                  21,            /* 21/32 in-band to broad-band ratio */
9697                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9698         },
9699         {                       /* f700 */
9700                 27844,          /* A1 = -1.699463 */
9701                  -32563,        /* A2 = 0.993744 */
9702                  -366,          /* B2 = -0.011187 */
9703                  0,             /* B1 = 0.000000 */
9704                  366,           /* B0 = 0.011187 */
9705                  27797,         /* A1 = -1.696655 */
9706                  -32686,        /* A2 = 0.997498 */
9707                  22748,         /* B2 = 0.694214 */
9708                  -19235,        /* B1 = -1.174072 */
9709                  22748,         /* B0 = 0.694214 */
9710                  27995,         /* A1 = -1.708740 */
9711                  -32688,        /* A2 = 0.997559 */
9712                  2964,          /* B2 = 0.090477 */
9713                  -2546,         /* B1 = -0.155449 */
9714                  2964,          /* B0 = 0.090477 */
9715                  5,             /* Internal filter scaling */
9716                  159,           /* Minimum in-band energy threshold */
9717                  21,            /* 21/32 in-band to broad-band ratio */
9718                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9719         },
9720         {                       /* f740 */
9721                 27297,          /* A1 = -1.666077 */
9722                  -32551,        /* A2 = 0.993408 */
9723                  -345,          /* B2 = -0.010540 */
9724                  0,             /* B1 = 0.000000 */
9725                  345,           /* B0 = 0.010540 */
9726                  27240,         /* A1 = -1.662598 */
9727                  -32683,        /* A2 = 0.997406 */
9728                  22560,         /* B2 = 0.688477 */
9729                  -18688,        /* B1 = -1.140625 */
9730                  22560,         /* B0 = 0.688477 */
9731                  27461,         /* A1 = -1.676147 */
9732                  -32684,        /* A2 = 0.997467 */
9733                  3541,          /* B2 = 0.108086 */
9734                  -2985,         /* B1 = -0.182220 */
9735                  3541,          /* B0 = 0.108086 */
9736                  5,             /* Internal filter scaling */
9737                  159,           /* Minimum in-band energy threshold */
9738                  21,            /* 21/32 in-band to broad-band ratio */
9739                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9740         },
9741         {                       /* f750 */
9742                 27155,          /* A1 = -1.657410 */
9743                  -32551,        /* A2 = 0.993408 */
9744                  -462,          /* B2 = -0.014117 */
9745                  0,             /* B1 = 0.000000 */
9746                  462,           /* B0 = 0.014117 */
9747                  27097,         /* A1 = -1.653870 */
9748                  -32683,        /* A2 = 0.997406 */
9749                  32495,         /* B2 = 0.991699 */
9750                  -26776,        /* B1 = -1.634338 */
9751                  32495,         /* B0 = 0.991699 */
9752                  27321,         /* A1 = -1.667542 */
9753                  -32684,        /* A2 = 0.997467 */
9754                  1835,          /* B2 = 0.056007 */
9755                  -1539,         /* B1 = -0.093948 */
9756                  1835,          /* B0 = 0.056007 */
9757                  5,             /* Internal filter scaling */
9758                  159,           /* Minimum in-band energy threshold */
9759                  21,            /* 21/32 in-band to broad-band ratio */
9760                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9761         },
9762         {                       /* f750_1450[] */
9763                 19298,          /* A1 = 1.177917 */
9764                  -24471,        /* A2 = -0.746796 */
9765                  -4152,         /* B2 = -0.126709 */
9766                  0,             /* B1 = 0 */
9767                  4152,          /* B0 = 0.126709 */
9768                  12902,         /* A1 = 0.787476 */
9769                  -29091,        /* A2 = -0.887817 */
9770                  12491,         /* B2 = 0.38121 */
9771                  -1794,         /* B1 = -0.109528 */
9772                  12494,         /* B0 = 0.381317 */
9773                  26291,         /* A1 = 1.604736 */
9774                  -30470,        /* A2 = -0.929901 */
9775                  28859,         /* B2 = 0.880737 */
9776                  -26084,        /* B1 = -1.592102 */
9777                  28861,         /* B0 = 0.880798 */
9778                  7,             /* Internal filter scaling */
9779                  159,           /* Minimum in-band energy threshold */
9780                  21,            /* 21/32 in-band to broad-band ratio */
9781                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9782         },
9783         {                       /* f770 */
9784                 26867,          /* A1 = -1.639832 */
9785                  -32551,        /* A2 = 0.993408 */
9786                  -123,          /* B2 = -0.003755 */
9787                  0,             /* B1 = 0.000000 */
9788                  123,           /* B0 = 0.003755 */
9789                  26805,         /* A1 = -1.636108 */
9790                  -32683,        /* A2 = 0.997406 */
9791                  17297,         /* B2 = 0.527863 */
9792                  -14096,        /* B1 = -0.860382 */
9793                  17297,         /* B0 = 0.527863 */
9794                  27034,         /* A1 = -1.650085 */
9795                  -32684,        /* A2 = 0.997467 */
9796                  12958,         /* B2 = 0.395477 */
9797                  -10756,        /* B1 = -0.656525 */
9798                  12958,         /* B0 = 0.395477 */
9799                  5,             /* Internal filter scaling */
9800                  159,           /* Minimum in-band energy threshold */
9801                  21,            /* 21/32 in-band to broad-band ratio */
9802                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9803         },
9804         {                       /* f800 */
9805                 26413,          /* A1 = -1.612122 */
9806                  -32547,        /* A2 = 0.993286 */
9807                  -223,          /* B2 = -0.006825 */
9808                  0,             /* B1 = 0.000000 */
9809                  223,           /* B0 = 0.006825 */
9810                  26342,         /* A1 = -1.607849 */
9811                  -32686,        /* A2 = 0.997498 */
9812                  6391,          /* B2 = 0.195053 */
9813                  -5120,         /* B1 = -0.312531 */
9814                  6391,          /* B0 = 0.195053 */
9815                  26593,         /* A1 = -1.623108 */
9816                  -32688,        /* A2 = 0.997559 */
9817                  23681,         /* B2 = 0.722717 */
9818                  -19328,        /* B1 = -1.179688 */
9819                  23681,         /* B0 = 0.722717 */
9820                  5,             /* Internal filter scaling */
9821                  159,           /* Minimum in-band energy threshold */
9822                  21,            /* 21/32 in-band to broad-band ratio */
9823                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9824         },
9825         {                       /* f816 */
9826                 26168,          /* A1 = -1.597209 */
9827                  -32528,        /* A2 = 0.992706 */
9828                  -235,          /* B2 = -0.007182 */
9829                  0,             /* B1 = 0.000000 */
9830                  235,           /* B0 = 0.007182 */
9831                  26092,         /* A1 = -1.592590 */
9832                  -32675,        /* A2 = 0.997192 */
9833                  20823,         /* B2 = 0.635498 */
9834                  -16510,        /* B1 = -1.007751 */
9835                  20823,         /* B0 = 0.635498 */
9836                  26363,         /* A1 = -1.609070 */
9837                  -32677,        /* A2 = 0.997253 */
9838                  6739,          /* B2 = 0.205688 */
9839                  -5459,         /* B1 = -0.333206 */
9840                  6739,          /* B0 = 0.205688 */
9841                  5,             /* Internal filter scaling */
9842                  159,           /* Minimum in-band energy threshold */
9843                  21,            /* 21/32 in-band to broad-band ratio */
9844                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9845         },
9846         {                       /* f850 */
9847                 25641,          /* A1 = -1.565063 */
9848                  -32536,        /* A2 = 0.992950 */
9849                  -121,          /* B2 = -0.003707 */
9850                  0,             /* B1 = 0.000000 */
9851                  121,           /* B0 = 0.003707 */
9852                  25560,         /* A1 = -1.560059 */
9853                  -32684,        /* A2 = 0.997437 */
9854                  18341,         /* B2 = 0.559753 */
9855                  -14252,        /* B1 = -0.869904 */
9856                  18341,         /* B0 = 0.559753 */
9857                  25837,         /* A1 = -1.577026 */
9858                  -32684,        /* A2 = 0.997467 */
9859                  16679,         /* B2 = 0.509003 */
9860                  -13232,        /* B1 = -0.807648 */
9861                  16679,         /* B0 = 0.509003 */
9862                  5,             /* Internal filter scaling */
9863                  159,           /* Minimum in-band energy threshold */
9864                  21,            /* 21/32 in-band to broad-band ratio */
9865                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9866         },
9867         {                       /* f857_1645[] */
9868                 16415,          /* A1 = 1.001953 */
9869                  -23669,        /* A2 = -0.722321 */
9870                  -4549,         /* B2 = -0.138847 */
9871                  0,             /* B1 = 0 */
9872                  4549,          /* B0 = 0.138847 */
9873                  8456,          /* A1 = 0.516174 */
9874                  -28996,        /* A2 = -0.884918 */
9875                  13753,         /* B2 = 0.419724 */
9876                  -12,           /* B1 = -0.000763 */
9877                  13757,         /* B0 = 0.419846 */
9878                  24632,         /* A1 = 1.503418 */
9879                  -30271,        /* A2 = -0.923828 */
9880                  29070,         /* B2 = 0.887146 */
9881                  -25265,        /* B1 = -1.542114 */
9882                  29073,         /* B0 = 0.887268 */
9883                  7,             /* Internal filter scaling */
9884                  159,           /* Minimum in-band energy threshold */
9885                  21,            /* 21/32 in-band to broad-band ratio */
9886                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9887         },
9888         {                       /* f900 */
9889                 24806,          /* A1 = -1.514099 */
9890                  -32501,        /* A2 = 0.991852 */
9891                  -326,          /* B2 = -0.009969 */
9892                  0,             /* B1 = 0.000000 */
9893                  326,           /* B0 = 0.009969 */
9894                  24709,         /* A1 = -1.508118 */
9895                  -32659,        /* A2 = 0.996674 */
9896                  20277,         /* B2 = 0.618835 */
9897                  -15182,        /* B1 = -0.926636 */
9898                  20277,         /* B0 = 0.618835 */
9899                  25022,         /* A1 = -1.527222 */
9900                  -32661,        /* A2 = 0.996735 */
9901                  4320,          /* B2 = 0.131836 */
9902                  -3331,         /* B1 = -0.203339 */
9903                  4320,          /* B0 = 0.131836 */
9904                  5,             /* Internal filter scaling */
9905                  159,           /* Minimum in-band energy threshold */
9906                  21,            /* 21/32 in-band to broad-band ratio */
9907                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9908         },
9909         {                       /* f900_1300[] */
9910                 19776,          /* A1 = 1.207092 */
9911                  -27437,        /* A2 = -0.837341 */
9912                  -2666,         /* B2 = -0.081371 */
9913                  0,             /* B1 = 0 */
9914                  2666,          /* B0 = 0.081371 */
9915                  16302,         /* A1 = 0.995026 */
9916                  -30354,        /* A2 = -0.926361 */
9917                  10389,         /* B2 = 0.317062 */
9918                  -3327,         /* B1 = -0.203064 */
9919                  10389,         /* B0 = 0.317062 */
9920                  24299,         /* A1 = 1.483154 */
9921                  -30930,        /* A2 = -0.943909 */
9922                  25016,         /* B2 = 0.763428 */
9923                  -21171,        /* B1 = -1.292236 */
9924                  25016,         /* B0 = 0.763428 */
9925                  7,             /* Internal filter scaling */
9926                  159,           /* Minimum in-band energy threshold */
9927                  21,            /* 21/32 in-band to broad-band ratio */
9928                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9929         },
9930         {                       /* f935_1215[] */
9931                 20554,          /* A1 = 1.254517 */
9932                  -28764,        /* A2 = -0.877838 */
9933                  -2048,         /* B2 = -0.062515 */
9934                  0,             /* B1 = 0 */
9935                  2048,          /* B0 = 0.062515 */
9936                  18209,         /* A1 = 1.11145 */
9937                  -30951,        /* A2 = -0.94458 */
9938                  9390,          /* B2 = 0.286575 */
9939                  -3955,         /* B1 = -0.241455 */
9940                  9390,          /* B0 = 0.286575 */
9941                  23902,         /* A1 = 1.458923 */
9942                  -31286,        /* A2 = -0.954803 */
9943                  23252,         /* B2 = 0.709595 */
9944                  -19132,        /* B1 = -1.167725 */
9945                  23252,         /* B0 = 0.709595 */
9946                  7,             /* Internal filter scaling */
9947                  159,           /* Minimum in-band energy threshold */
9948                  21,            /* 21/32 in-band to broad-band ratio */
9949                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9950         },
9951         {                       /* f941_1477[] */
9952                 17543,          /* A1 = 1.07074 */
9953                  -26220,        /* A2 = -0.800201 */
9954                  -3298,         /* B2 = -0.100647 */
9955                  0,             /* B1 = 0 */
9956                  3298,          /* B0 = 0.100647 */
9957                  12423,         /* A1 = 0.75827 */
9958                  -30036,        /* A2 = -0.916626 */
9959                  12651,         /* B2 = 0.386078 */
9960                  -2444,         /* B1 = -0.14917 */
9961                  12653,         /* B0 = 0.386154 */
9962                  23518,         /* A1 = 1.435425 */
9963                  -30745,        /* A2 = -0.938293 */
9964                  27282,         /* B2 = 0.832581 */
9965                  -22529,        /* B1 = -1.375122 */
9966                  27286,         /* B0 = 0.832703 */
9967                  7,             /* Internal filter scaling */
9968                  159,           /* Minimum in-band energy threshold */
9969                  21,            /* 21/32 in-band to broad-band ratio */
9970                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9971         },
9972         {                       /* f942 */
9973                 24104,          /* A1 = -1.471252 */
9974                  -32507,        /* A2 = 0.992065 */
9975                  -351,          /* B2 = -0.010722 */
9976                  0,             /* B1 = 0.000000 */
9977                  351,           /* B0 = 0.010722 */
9978                  23996,         /* A1 = -1.464600 */
9979                  -32671,        /* A2 = 0.997040 */
9980                  22848,         /* B2 = 0.697266 */
9981                  -16639,        /* B1 = -1.015564 */
9982                  22848,         /* B0 = 0.697266 */
9983                  24332,         /* A1 = -1.485168 */
9984                  -32673,        /* A2 = 0.997101 */
9985                  4906,          /* B2 = 0.149727 */
9986                  -3672,         /* B1 = -0.224174 */
9987                  4906,          /* B0 = 0.149727 */
9988                  5,             /* Internal filter scaling */
9989                  159,           /* Minimum in-band energy threshold */
9990                  21,            /* 21/32 in-band to broad-band ratio */
9991                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9992         },
9993         {                       /* f950 */
9994                 23967,          /* A1 = -1.462830 */
9995                  -32507,        /* A2 = 0.992065 */
9996                  -518,          /* B2 = -0.015821 */
9997                  0,             /* B1 = 0.000000 */
9998                  518,           /* B0 = 0.015821 */
9999                  23856,         /* A1 = -1.456055 */
10000                  -32671,        /* A2 = 0.997040 */
10001                  26287,         /* B2 = 0.802246 */
10002                  -19031,        /* B1 = -1.161560 */
10003                  26287,         /* B0 = 0.802246 */
10004                  24195,         /* A1 = -1.476746 */
10005                  -32673,        /* A2 = 0.997101 */
10006                  2890,          /* B2 = 0.088196 */
10007                  -2151,         /* B1 = -0.131317 */
10008                  2890,          /* B0 = 0.088196 */
10009                  5,             /* Internal filter scaling */
10010                  159,           /* Minimum in-band energy threshold */
10011                  21,            /* 21/32 in-band to broad-band ratio */
10012                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10013         },
10014         {                       /* f950_1400[] */
10015                 18294,          /* A1 = 1.116638 */
10016                  -26962,        /* A2 = -0.822845 */
10017                  -2914,         /* B2 = -0.088936 */
10018                  0,             /* B1 = 0 */
10019                  2914,          /* B0 = 0.088936 */
10020                  14119,         /* A1 = 0.861786 */
10021                  -30227,        /* A2 = -0.922455 */
10022                  11466,         /* B2 = 0.349945 */
10023                  -2833,         /* B1 = -0.172943 */
10024                  11466,         /* B0 = 0.349945 */
10025                  23431,         /* A1 = 1.430115 */
10026                  -30828,        /* A2 = -0.940796 */
10027                  25331,         /* B2 = 0.773071 */
10028                  -20911,        /* B1 = -1.276367 */
10029                  25331,         /* B0 = 0.773071 */
10030                  7,             /* Internal filter scaling */
10031                  159,           /* Minimum in-band energy threshold */
10032                  21,            /* 21/32 in-band to broad-band ratio */
10033                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10034         },
10035         {                       /* f975 */
10036                 23521,          /* A1 = -1.435608 */
10037                  -32489,        /* A2 = 0.991516 */
10038                  -193,          /* B2 = -0.005915 */
10039                  0,             /* B1 = 0.000000 */
10040                  193,           /* B0 = 0.005915 */
10041                  23404,         /* A1 = -1.428467 */
10042                  -32655,        /* A2 = 0.996582 */
10043                  17740,         /* B2 = 0.541412 */
10044                  -12567,        /* B1 = -0.767029 */
10045                  17740,         /* B0 = 0.541412 */
10046                  23753,         /* A1 = -1.449829 */
10047                  -32657,        /* A2 = 0.996613 */
10048                  9090,          /* B2 = 0.277405 */
10049                  -6662,         /* B1 = -0.406647 */
10050                  9090,          /* B0 = 0.277405 */
10051                  5,             /* Internal filter scaling */
10052                  159,           /* Minimum in-band energy threshold */
10053                  21,            /* 21/32 in-band to broad-band ratio */
10054                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10055         },
10056         {                       /* f1000 */
10057                 23071,          /* A1 = -1.408203 */
10058                  -32489,        /* A2 = 0.991516 */
10059                  -293,          /* B2 = -0.008965 */
10060                  0,             /* B1 = 0.000000 */
10061                  293,           /* B0 = 0.008965 */
10062                  22951,         /* A1 = -1.400818 */
10063                  -32655,        /* A2 = 0.996582 */
10064                  5689,          /* B2 = 0.173645 */
10065                  -3951,         /* B1 = -0.241150 */
10066                  5689,          /* B0 = 0.173645 */
10067                  23307,         /* A1 = -1.422607 */
10068                  -32657,        /* A2 = 0.996613 */
10069                  18692,         /* B2 = 0.570435 */
10070                  -13447,        /* B1 = -0.820770 */
10071                  18692,         /* B0 = 0.570435 */
10072                  5,             /* Internal filter scaling */
10073                  159,           /* Minimum in-band energy threshold */
10074                  21,            /* 21/32 in-band to broad-band ratio */
10075                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10076         },
10077         {                       /* f1020 */
10078                 22701,          /* A1 = -1.385620 */
10079                  -32474,        /* A2 = 0.991058 */
10080                  -292,          /* B2 = -0.008933 */
10081                  0,             /*163840      , B1 = 10.000000 */
10082                  292,           /* B0 = 0.008933 */
10083                  22564,         /* A1 = -1.377258 */
10084                  -32655,        /* A2 = 0.996552 */
10085                  20756,         /* B2 = 0.633423 */
10086                  -14176,        /* B1 = -0.865295 */
10087                  20756,         /* B0 = 0.633423 */
10088                  22960,         /* A1 = -1.401428 */
10089                  -32657,        /* A2 = 0.996613 */
10090                  6520,          /* B2 = 0.198990 */
10091                  -4619,         /* B1 = -0.281937 */
10092                  6520,          /* B0 = 0.198990 */
10093                  5,             /* Internal filter scaling */
10094                  159,           /* Minimum in-band energy threshold */
10095                  21,            /* 21/32 in-band to broad-band ratio */
10096                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10097         },
10098         {                       /* f1050 */
10099                 22142,          /* A1 = -1.351501 */
10100                  -32474,        /* A2 = 0.991058 */
10101                  -147,          /* B2 = -0.004493 */
10102                  0,             /* B1 = 0.000000 */
10103                  147,           /* B0 = 0.004493 */
10104                  22000,         /* A1 = -1.342834 */
10105                  -32655,        /* A2 = 0.996552 */
10106                  15379,         /* B2 = 0.469360 */
10107                  -10237,        /* B1 = -0.624847 */
10108                  15379,         /* B0 = 0.469360 */
10109                  22406,         /* A1 = -1.367554 */
10110                  -32657,        /* A2 = 0.996613 */
10111                  17491,         /* B2 = 0.533783 */
10112                  -12096,        /* B1 = -0.738312 */
10113                  17491,         /* B0 = 0.533783 */
10114                  5,             /* Internal filter scaling */
10115                  159,           /* Minimum in-band energy threshold */
10116                  21,            /* 21/32 in-band to broad-band ratio */
10117                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10118         },
10119         {                       /* f1100_1750[] */
10120                 12973,          /* A1 = 0.79184 */
10121                  -24916,        /* A2 = -0.760376 */
10122                  6655,          /* B2 = 0.203102 */
10123                  367,           /* B1 = 0.0224 */
10124                  6657,          /* B0 = 0.203171 */
10125                  5915,          /* A1 = 0.361053 */
10126                  -29560,        /* A2 = -0.90213 */
10127                  -7777,         /* B2 = -0.23735 */
10128                  0,             /* B1 = 0 */
10129                  7777,          /* B0 = 0.23735 */
10130                  20510,         /* A1 = 1.251892 */
10131                  -30260,        /* A2 = -0.923462 */
10132                  26662,         /* B2 = 0.81366 */
10133                  -20573,        /* B1 = -1.255737 */
10134                  26668,         /* B0 = 0.813843 */
10135                  7,             /* Internal filter scaling */
10136                  159,           /* Minimum in-band energy threshold */
10137                  21,            /* 21/32 in-band to broad-band ratio */
10138                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10139         },
10140         {                       /* f1140 */
10141                 20392,          /* A1 = -1.244629 */
10142                  -32460,        /* A2 = 0.990601 */
10143                  -270,          /* B2 = -0.008240 */
10144                  0,             /* B1 = 0.000000 */
10145                  270,           /* B0 = 0.008240 */
10146                  20218,         /* A1 = -1.234009 */
10147                  -32655,        /* A2 = 0.996582 */
10148                  21337,         /* B2 = 0.651154 */
10149                  -13044,        /* B1 = -0.796143 */
10150                  21337,         /* B0 = 0.651154 */
10151                  20684,         /* A1 = -1.262512 */
10152                  -32657,        /* A2 = 0.996643 */
10153                  8572,          /* B2 = 0.261612 */
10154                  -5476,         /* B1 = -0.334244 */
10155                  8572,          /* B0 = 0.261612 */
10156                  5,             /* Internal filter scaling */
10157                  159,           /* Minimum in-band energy threshold */
10158                  21,            /* 21/32 in-band to broad-band ratio */
10159                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10160         },
10161         {                       /* f1200 */
10162                 19159,          /* A1 = -1.169373 */
10163                  -32456,        /* A2 = 0.990509 */
10164                  -335,          /* B2 = -0.010252 */
10165                  0,             /* B1 = 0.000000 */
10166                  335,           /* B0 = 0.010252 */
10167                  18966,         /* A1 = -1.157593 */
10168                  -32661,        /* A2 = 0.996735 */
10169                  6802,          /* B2 = 0.207588 */
10170                  -3900,         /* B1 = -0.238098 */
10171                  6802,          /* B0 = 0.207588 */
10172                  19467,         /* A1 = -1.188232 */
10173                  -32661,        /* A2 = 0.996765 */
10174                  25035,         /* B2 = 0.764008 */
10175                  -15049,        /* B1 = -0.918579 */
10176                  25035,         /* B0 = 0.764008 */
10177                  5,             /* Internal filter scaling */
10178                  159,           /* Minimum in-band energy threshold */
10179                  21,            /* 21/32 in-band to broad-band ratio */
10180                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10181         },
10182         {                       /* f1209 */
10183                 18976,          /* A1 = -1.158264 */
10184                  -32439,        /* A2 = 0.989990 */
10185                  -183,          /* B2 = -0.005588 */
10186                  0,             /* B1 = 0.000000 */
10187                  183,           /* B0 = 0.005588 */
10188                  18774,         /* A1 = -1.145874 */
10189                  -32650,        /* A2 = 0.996429 */
10190                  15468,         /* B2 = 0.472076 */
10191                  -8768,         /* B1 = -0.535217 */
10192                  15468,         /* B0 = 0.472076 */
10193                  19300,         /* A1 = -1.177979 */
10194                  -32652,        /* A2 = 0.996490 */
10195                  19840,         /* B2 = 0.605499 */
10196                  -11842,        /* B1 = -0.722809 */
10197                  19840,         /* B0 = 0.605499 */
10198                  5,             /* Internal filter scaling */
10199                  159,           /* Minimum in-band energy threshold */
10200                  21,            /* 21/32 in-band to broad-band ratio */
10201                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10202         },
10203         {                       /* f1330 */
10204                 16357,          /* A1 = -0.998413 */
10205                  -32368,        /* A2 = 0.987793 */
10206                  -217,          /* B2 = -0.006652 */
10207                  0,             /* B1 = 0.000000 */
10208                  217,           /* B0 = 0.006652 */
10209                  16107,         /* A1 = -0.983126 */
10210                  -32601,        /* A2 = 0.994904 */
10211                  11602,         /* B2 = 0.354065 */
10212                  -5555,         /* B1 = -0.339111 */
10213                  11602,         /* B0 = 0.354065 */
10214                  16722,         /* A1 = -1.020630 */
10215                  -32603,        /* A2 = 0.994965 */
10216                  15574,         /* B2 = 0.475311 */
10217                  -8176,         /* B1 = -0.499069 */
10218                  15574,         /* B0 = 0.475311 */
10219                  5,             /* Internal filter scaling */
10220                  159,           /* Minimum in-band energy threshold */
10221                  21,            /* 21/32 in-band to broad-band ratio */
10222                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10223         },
10224         {                       /* f1336 */
10225                 16234,          /* A1 = -0.990875 */
10226                  32404,         /* A2 = -0.988922 */
10227                  -193,          /* B2 = -0.005908 */
10228                  0,             /* B1 = 0.000000 */
10229                  193,           /* B0 = 0.005908 */
10230                  15986,         /* A1 = -0.975769 */
10231                  -32632,        /* A2 = 0.995880 */
10232                  18051,         /* B2 = 0.550903 */
10233                  -8658,         /* B1 = -0.528473 */
10234                  18051,         /* B0 = 0.550903 */
10235                  16591,         /* A1 = -1.012695 */
10236                  -32634,        /* A2 = 0.995941 */
10237                  15736,         /* B2 = 0.480240 */
10238                  -8125,         /* B1 = -0.495926 */
10239                  15736,         /* B0 = 0.480240 */
10240                  5,             /* Internal filter scaling */
10241                  159,           /* Minimum in-band energy threshold */
10242                  21,            /* 21/32 in-band to broad-band ratio */
10243                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10244         },
10245         {                       /* f1366 */
10246                 15564,          /* A1 = -0.949982 */
10247                  -32404,        /* A2 = 0.988922 */
10248                  -269,          /* B2 = -0.008216 */
10249                  0,             /* B1 = 0.000000 */
10250                  269,           /* B0 = 0.008216 */
10251                  15310,         /* A1 = -0.934479 */
10252                  -32632,        /* A2 = 0.995880 */
10253                  10815,         /* B2 = 0.330063 */
10254                  -4962,         /* B1 = -0.302887 */
10255                  10815,         /* B0 = 0.330063 */
10256                  15924,         /* A1 = -0.971924 */
10257                  -32634,        /* A2 = 0.995941 */
10258                  18880,         /* B2 = 0.576172 */
10259                  -9364,         /* B1 = -0.571594 */
10260                  18880,         /* B0 = 0.576172 */
10261                  5,             /* Internal filter scaling */
10262                  159,           /* Minimum in-band energy threshold */
10263                  21,            /* 21/32 in-band to broad-band ratio */
10264                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10265         },
10266         {                       /* f1380 */
10267                 15247,          /* A1 = -0.930603 */
10268                  -32397,        /* A2 = 0.988708 */
10269                  -244,          /* B2 = -0.007451 */
10270                  0,             /* B1 = 0.000000 */
10271                  244,           /* B0 = 0.007451 */
10272                  14989,         /* A1 = -0.914886 */
10273                  -32627,        /* A2 = 0.995697 */
10274                  18961,         /* B2 = 0.578644 */
10275                  -8498,         /* B1 = -0.518707 */
10276                  18961,         /* B0 = 0.578644 */
10277                  15608,         /* A1 = -0.952667 */
10278                  -32628,        /* A2 = 0.995758 */
10279                  11145,         /* B2 = 0.340134 */
10280                  -5430,         /* B1 = -0.331467 */
10281                  11145,         /* B0 = 0.340134 */
10282                  5,             /* Internal filter scaling */
10283                  159,           /* Minimum in-band energy threshold */
10284                  21,            /* 21/32 in-band to broad-band ratio */
10285                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10286         },
10287         {                       /* f1400 */
10288                 14780,          /* A1 = -0.902130 */
10289                  -32393,        /* A2 = 0.988586 */
10290                  -396,          /* B2 = -0.012086 */
10291                  0,             /* B1 = 0.000000 */
10292                  396,           /* B0 = 0.012086 */
10293                  14510,         /* A1 = -0.885651 */
10294                  -32630,        /* A2 = 0.995819 */
10295                  6326,          /* B2 = 0.193069 */
10296                  -2747,         /* B1 = -0.167671 */
10297                  6326,          /* B0 = 0.193069 */
10298                  15154,         /* A1 = -0.924957 */
10299                  -32632,        /* A2 = 0.995850 */
10300                  23235,         /* B2 = 0.709076 */
10301                  -10983,        /* B1 = -0.670380 */
10302                  23235,         /* B0 = 0.709076 */
10303                  5,             /* Internal filter scaling */
10304                  159,           /* Minimum in-band energy threshold */
10305                  21,            /* 21/32 in-band to broad-band ratio */
10306                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10307         },
10308         {                       /* f1477 */
10309                 13005,          /* A1 = -0.793793 */
10310                  -32368,        /* A2 = 0.987823 */
10311                  -500,          /* B2 = -0.015265 */
10312                  0,             /* B1 = 0.000000 */
10313                  500,           /* B0 = 0.015265 */
10314                  12708,         /* A1 = -0.775665 */
10315                  -32615,        /* A2 = 0.995331 */
10316                  11420,         /* B2 = 0.348526 */
10317                  -4306,         /* B1 = -0.262833 */
10318                  11420,         /* B0 = 0.348526 */
10319                  13397,         /* A1 = -0.817688 */
10320                  -32615,        /* A2 = 0.995361 */
10321                  9454,          /* B2 = 0.288528 */
10322                  -3981,         /* B1 = -0.243027 */
10323                  9454,          /* B0 = 0.288528 */
10324                  5,             /* Internal filter scaling */
10325                  159,           /* Minimum in-band energy threshold */
10326                  21,            /* 21/32 in-band to broad-band ratio */
10327                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10328         },
10329         {                       /* f1600 */
10330                 10046,          /* A1 = -0.613190 */
10331                  -32331,        /* A2 = 0.986694 */
10332                  -455,          /* B2 = -0.013915 */
10333                  0,             /* B1 = 0.000000 */
10334                  455,           /* B0 = 0.013915 */
10335                  9694,          /* A1 = -0.591705 */
10336                  -32601,        /* A2 = 0.994934 */
10337                  6023,          /* B2 = 0.183815 */
10338                  -1708,         /* B1 = -0.104279 */
10339                  6023,          /* B0 = 0.183815 */
10340                  10478,         /* A1 = -0.639587 */
10341                  -32603,        /* A2 = 0.994965 */
10342                  22031,         /* B2 = 0.672333 */
10343                  -7342,         /* B1 = -0.448151 */
10344                  22031,         /* B0 = 0.672333 */
10345                  5,             /* Internal filter scaling */
10346                  159,           /* Minimum in-band energy threshold */
10347                  21,            /* 21/32 in-band to broad-band ratio */
10348                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10349         },
10350         {                       /* f1633_1638[] */
10351                 9181,           /* A1 = 0.560394 */
10352                  -32256,        /* A2 = -0.984375 */
10353                  -556,          /* B2 = -0.016975 */
10354                  0,             /* B1 = 0 */
10355                  556,           /* B0 = 0.016975 */
10356                  8757,          /* A1 = 0.534515 */
10357                  -32574,        /* A2 = -0.99408 */
10358                  8443,          /* B2 = 0.25769 */
10359                  -2135,         /* B1 = -0.130341 */
10360                  8443,          /* B0 = 0.25769 */
10361                  9691,          /* A1 = 0.591522 */
10362                  -32574,        /* A2 = -0.99411 */
10363                  15446,         /* B2 = 0.471375 */
10364                  -4809,         /* B1 = -0.293579 */
10365                  15446,         /* B0 = 0.471375 */
10366                  7,             /* Internal filter scaling */
10367                  159,           /* Minimum in-band energy threshold */
10368                  21,            /* 21/32 in-band to broad-band ratio */
10369                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10370         },
10371         {                       /* f1800 */
10372                 5076,           /* A1 = -0.309875 */
10373                  -32304,        /* A2 = 0.985840 */
10374                  -508,          /* B2 = -0.015503 */
10375                  0,             /* B1 = 0.000000 */
10376                  508,           /* B0 = 0.015503 */
10377                  4646,          /* A1 = -0.283600 */
10378                  -32605,        /* A2 = 0.995026 */
10379                  6742,          /* B2 = 0.205780 */
10380                  -878,          /* B1 = -0.053635 */
10381                  6742,          /* B0 = 0.205780 */
10382                  5552,          /* A1 = -0.338928 */
10383                  -32605,        /* A2 = 0.995056 */
10384                  23667,         /* B2 = 0.722260 */
10385                  -4297,         /* B1 = -0.262329 */
10386                  23667,         /* B0 = 0.722260 */
10387                  5,             /* Internal filter scaling */
10388                  159,           /* Minimum in-band energy threshold */
10389                  21,            /* 21/32 in-band to broad-band ratio */
10390                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10391         },
10392         {                       /* f1860 */
10393                 3569,           /* A1 = -0.217865 */
10394                  -32292,        /* A2 = 0.985504 */
10395                  -239,          /* B2 = -0.007322 */
10396                  0,             /* B1 = 0.000000 */
10397                  239,           /* B0 = 0.007322 */
10398                  3117,          /* A1 = -0.190277 */
10399                  -32603,        /* A2 = 0.994965 */
10400                  18658,         /* B2 = 0.569427 */
10401                  -1557,         /* B1 = -0.095032 */
10402                  18658,         /* B0 = 0.569427 */
10403                  4054,          /* A1 = -0.247437 */
10404                  -32603,        /* A2 = 0.994965 */
10405                  18886,         /* B2 = 0.576385 */
10406                  -2566,         /* B1 = -0.156647 */
10407                  18886,         /* B0 = 0.576385 */
10408                  5,             /* Internal filter scaling */
10409                  159,           /* Minimum in-band energy threshold */
10410                  21,            /* 21/32 in-band to broad-band ratio */
10411                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10412         },
10413 };
10414 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10415 {
10416         unsigned short cmd;
10417         int cnt, max;
10418
10419         if (jf->filter > 3) {
10420                 return -1;
10421         }
10422         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10423
10424                 return -1;
10425         if (!jf->enable) {
10426                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10427
10428                         return -1;
10429                 else
10430                         return 0;
10431         } else {
10432                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10433
10434                         return -1;
10435                 /* Select the filter (f0 - f3) to use. */
10436                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10437                         return -1;
10438         }
10439         if (jf->freq < 12 && jf->freq > 3) {
10440                 /* Select the frequency for the selected filter. */
10441                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10442                         return -1;
10443         } else if (jf->freq > 11) {
10444                 /* We need to load a programmable filter set for undefined */
10445                 /* frequencies.  So we will point the filter to a programmable set. */
10446                 /* Since there are only 4 filters and 4 programmable sets, we will */
10447                 /* just point the filter to the same number set and program it for the */
10448                 /* frequency we want. */
10449                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10450                         return -1;
10451                 if (j->ver.low != 0x12) {
10452                         cmd = 0x515B;
10453                         max = 19;
10454                 } else {
10455                         cmd = 0x515E;
10456                         max = 15;
10457                 }
10458                 if (ixj_WriteDSPCommand(cmd, j))
10459                         return -1;
10460                 for (cnt = 0; cnt < max; cnt++) {
10461                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10462                                 return -1;
10463                 }
10464         }
10465         j->filter_en[jf->filter] = jf->enable;
10466         return 0;
10467 }
10468
10469 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10470 {
10471         unsigned short cmd;
10472         int cnt, max;
10473         if (jfr->filter > 3) {
10474                 return -1;
10475         }
10476         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10477                 return -1;
10478
10479         if (!jfr->enable) {
10480                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10481                         return -1;
10482                 else
10483                         return 0;
10484         } else {
10485                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10486                         return -1;
10487                 /* Select the filter (f0 - f3) to use. */
10488                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10489                         return -1;
10490         }
10491         /* We need to load a programmable filter set for undefined */
10492         /* frequencies.  So we will point the filter to a programmable set. */
10493         /* Since there are only 4 filters and 4 programmable sets, we will */
10494         /* just point the filter to the same number set and program it for the */
10495         /* frequency we want. */
10496         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10497                 return -1;
10498         if (j->ver.low != 0x12) {
10499                 cmd = 0x515B;
10500                 max = 19;
10501         } else {
10502                 cmd = 0x515E;
10503                 max = 15;
10504         }
10505         if (ixj_WriteDSPCommand(cmd, j))
10506                 return -1;
10507         for (cnt = 0; cnt < max; cnt++) {
10508                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10509                         return -1;
10510         }
10511         j->filter_en[jfr->filter] = jfr->enable;
10512         return 0;
10513 }
10514
10515 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10516 {
10517         int freq0, freq1;
10518         unsigned short data;
10519         if (ti->freq0) {
10520                 freq0 = ti->freq0;
10521         } else {
10522                 freq0 = 0x7FFF;
10523         }
10524
10525         if (ti->freq1) {
10526                 freq1 = ti->freq1;
10527         } else {
10528                 freq1 = 0x7FFF;
10529         }
10530
10531         if(ti->tone_index > 12 && ti->tone_index < 28)
10532         {
10533                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10534                         return -1;
10535                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10536                         return -1;
10537                 data = freq0;
10538                 if (ixj_WriteDSPCommand(data, j))
10539                         return -1;
10540                 data = freq1;
10541                 if (ixj_WriteDSPCommand(data, j))
10542                         return -1;
10543         }
10544         return freq0;
10545 }
10546