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

   1 /****************************************************************************
   2  *    ixj.c
   3  *
   4  * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
   5  * including the Internet PhoneJACK, Internet PhoneJACK Lite,
   6  * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
   7  * SmartCABLE
   8  *
   9  *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
  10  *
  11  *    This program is free software; you can redistribute it and/or
  12  *    modify it under the terms of the GNU General Public License
  13  *    as published by the Free Software Foundation; either version
  14  *    2 of the License, or (at your option) any later version.
  15  *
  16  * Author:          Ed Okerson, <eokerson@quicknet.net>
  17  *
  18  * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  19  *                  David W. Erhart, <derhart@quicknet.net>
  20  *                  John Sellers, <jsellers@quicknet.net>
  21  *                  Mike Preston, <mpreston@quicknet.net>
  22  *
  23  * Fixes:           David Huggins-Daines, <dhd@cepstral.com>
  24  *                  Fabio Ferrari, <fabio.ferrari@digitro.com.br>
  25  *                  Artis Kugevics, <artis@mt.lv>
  26  *                  Daniele Bellucci, <bellucda@tiscali.it>
  27  *
  28  * More information about the hardware related to this driver can be found
  29  * at our website:    http://www.quicknet.net
  30  *
  31  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  32  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  34  * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
  40  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41  *
  42  ***************************************************************************/
  43
  44 /*
  45  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  46  * Audit some copy_*_user and minor cleanup.
  47  *
  48  * Revision 4.7  2001/08/13 06:19:33  craigs
  49  * Added additional changes from Alan Cox and John Anderson for
  50  * 2.2 to 2.4 cleanup and bounds checking
  51  *
  52  * Revision 4.6  2001/08/13 01:05:05  craigs
  53  * Really fixed PHONE_QUERY_CODEC problem this time
  54  *
  55  * Revision 4.5  2001/08/13 00:11:03  craigs
  56  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  57  *
  58  * Revision 4.4  2001/08/07 07:58:12  craigs
  59  * Changed back to three digit version numbers
  60  * Added tagbuild target to allow automatic and easy tagging of versions
  61  *
  62  * Revision 4.3  2001/08/07 07:24:47  craigs
  63  * Added ixj-ver.h to allow easy configuration management of driver
  64  * Added display of version number in /prox/ixj
  65  *
  66  * Revision 4.2  2001/08/06 07:07:19  craigs
  67  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  68  * behaviour of returning int rather than short *
  69  *
  70  * Revision 4.1  2001/08/05 00:17:37  craigs
  71  * More changes for correct PCMCIA installation
  72  * Start of changes for backward Linux compatibility
  73  *
  74  * Revision 4.0  2001/08/04 12:33:12  craigs
  75  * New version using GNU autoconf
  76  *
  77  * Revision 3.105  2001/07/20 23:14:32  eokerson
  78  * More work on CallerID generation when using ring cadences.
  79  *
  80  * Revision 3.104  2001/07/06 01:33:55  eokerson
  81  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  82  *
  83  * Revision 3.103  2001/07/05 19:20:16  eokerson
  84  * Updated HOWTO
  85  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  86  *
  87  * Revision 3.102  2001/07/03 23:51:21  eokerson
  88  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  89  *
  90  * Revision 3.101  2001/07/02 19:26:56  eokerson
  91  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  92  *
  93  * Revision 3.100  2001/07/02 19:18:27  eokerson
  94  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  95  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  96  * Fixed speaker mode on Internet LineJACK.
  97  *
  98  * Revision 3.99  2001/05/09 14:11:16  eokerson
  99  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 100  *
 101  * Revision 3.98  2001/05/08 19:55:33  eokerson
 102  * Fixed POTS hookstate detection while it is connected to PSTN port.
 103  *
 104  * Revision 3.97  2001/05/08 00:01:04  eokerson
 105  * Fixed kernel oops when sending caller ID data.
 106  *
 107  * Revision 3.96  2001/05/04 23:09:30  eokerson
 108  * Now uses one kernel timer for each card, instead of one for the entire driver.
 109  *
 110  * Revision 3.95  2001/04/25 22:06:47  eokerson
 111  * Fixed squawking at beginning of some G.723.1 calls.
 112  *
 113  * Revision 3.94  2001/04/03 23:42:00  eokerson
 114  * Added linear volume ioctls
 115  * Added raw filter load ioctl
 116  *
 117  * Revision 3.93  2001/02/27 01:00:06  eokerson
 118  * Fixed blocking in CallerID.
 119  * Reduced size of ixj structure for smaller driver footprint.
 120  *
 121  * Revision 3.92  2001/02/20 22:02:59  eokerson
 122  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 123  * Improved PSTN ring detection.
 124  * Fixed wink generation on POTS ports.
 125  *
 126  * Revision 3.91  2001/02/13 00:55:44  eokerson
 127  * Turn AEC back on after changing frame sizes.
 128  *
 129  * Revision 3.90  2001/02/12 16:42:00  eokerson
 130  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 131  *
 132  * Revision 3.89  2001/02/12 15:41:16  eokerson
 133  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 134  *
 135  * Revision 3.88  2001/02/05 23:25:42  eokerson
 136  * Fixed lockup bugs with deregister.
 137  *
 138  * Revision 3.87  2001/01/29 21:00:39  eokerson
 139  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 140  * Updated copyright date.
 141  *
 142  * Revision 3.86  2001/01/23 23:53:46  eokerson
 143  * Fixes to G.729 compatibility.
 144  *
 145  * Revision 3.85  2001/01/23 21:30:36  eokerson
 146  * Added verbage about cards supported.
 147  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 148  *
 149  * Revision 3.84  2001/01/22 23:32:10  eokerson
 150  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 151  *
 152  * Revision 3.83  2001/01/19 14:51:41  eokerson
 153  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 154  *
 155  * Revision 3.82  2001/01/19 00:34:49  eokerson
 156  * Added verbosity to write overlap errors.
 157  *
 158  * Revision 3.81  2001/01/18 23:56:54  eokerson
 159  * Fixed PSTN line test functions.
 160  *
 161  * Revision 3.80  2001/01/18 22:29:27  eokerson
 162  * Updated AEC/AGC values for different cards.
 163  *
 164  * Revision 3.79  2001/01/17 02:58:54  eokerson
 165  * Fixed AEC reset after Caller ID.
 166  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 167  *
 168  * Revision 3.78  2001/01/16 19:43:09  eokerson
 169  * Added support for Linux 2.4.x kernels.
 170  *
 171  * Revision 3.77  2001/01/09 04:00:52  eokerson
 172  * Linetest will now test the line, even if it has previously succeded.
 173  *
 174  * Revision 3.76  2001/01/08 19:27:00  eokerson
 175  * Fixed problem with standard cable on Internet PhoneCARD.
 176  *
 177  * Revision 3.75  2000/12/22 16:52:14  eokerson
 178  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 179  *
 180  * Revision 3.74  2000/12/08 22:41:50  eokerson
 181  * Added capability for G729B.
 182  *
 183  * Revision 3.73  2000/12/07 23:35:16  eokerson
 184  * Added capability to have different ring pattern before CallerID data.
 185  * Added hookstate checks in CallerID routines to stop FSK.
 186  *
 187  * Revision 3.72  2000/12/06 19:31:31  eokerson
 188  * Modified signal behavior to only send one signal per event.
 189  *
 190  * Revision 3.71  2000/12/06 03:23:08  eokerson
 191  * Fixed CallerID on Call Waiting.
 192  *
 193  * Revision 3.70  2000/12/04 21:29:37  eokerson
 194  * Added checking to Smart Cable gain functions.
 195  *
 196  * Revision 3.69  2000/12/04 21:05:20  eokerson
 197  * Changed ixjdebug levels.
 198  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 199  *
 200  * Revision 3.68  2000/12/04 00:17:21  craigs
 201  * Changed mixer voice gain to +6dB rather than 0dB
 202  *
 203  * Revision 3.67  2000/11/30 21:25:51  eokerson
 204  * Fixed write signal errors.
 205  *
 206  * Revision 3.66  2000/11/29 22:42:44  eokerson
 207  * Fixed PSTN ring detect problems.
 208  *
 209  * Revision 3.65  2000/11/29 07:31:55  craigs
 210  * Added new 425Hz filter co-efficients
 211  * Added card-specific DTMF prescaler initialisation
 212  *
 213  * Revision 3.64  2000/11/28 14:03:32  craigs
 214  * Changed certain mixer initialisations to be 0dB rather than 12dB
 215  * Added additional information to /proc/ixj
 216  *
 217  * Revision 3.63  2000/11/28 11:38:41  craigs
 218  * Added display of AEC modes in AUTO and AGC mode
 219  *
 220  * Revision 3.62  2000/11/28 04:05:44  eokerson
 221  * Improved PSTN ring detection routine.
 222  *
 223  * Revision 3.61  2000/11/27 21:53:12  eokerson
 224  * Fixed flash detection.
 225  *
 226  * Revision 3.60  2000/11/27 15:57:29  eokerson
 227  * More work on G.729 load routines.
 228  *
 229  * Revision 3.59  2000/11/25 21:55:12  eokerson
 230  * Fixed errors in G.729 load routine.
 231  *
 232  * Revision 3.58  2000/11/25 04:08:29  eokerson
 233  * Added board locks around G.729 and TS85 load routines.
 234  *
 235  * Revision 3.57  2000/11/24 05:35:17  craigs
 236  * Added ability to retrieve mixer values on LineJACK
 237  * Added complete initialisation of all mixer values at startup
 238  * Fixed spelling mistake
 239  *
 240  * Revision 3.56  2000/11/23 02:52:11  robertj
 241  * Added cvs change log keyword.
 242  * Fixed bug in capabilities list when using G.729 module.
 243  *
 244  */
 245
 246 #include "ixj-ver.h"
 247
 248 #define PERFMON_STATS
 249 #define IXJDEBUG 0
 250 #define MAXRINGS 5
 251
 252 #include <linux/module.h>
 253
 254 #include <linux/init.h>
 255 #include <linux/sched.h>
 256 #include <linux/kernel.h>       /* printk() */
 257 #include <linux/fs.h>           /* everything... */
 258 #include <linux/errno.h>        /* error codes */
 259 #include <linux/slab.h>
 260 #include <linux/mm.h>
 261 #include <linux/ioport.h>
 262 #include <linux/interrupt.h>
 263 #include <linux/proc_fs.h>
 264 #include <linux/poll.h>
 265 #include <linux/timer.h>
 266 #include <linux/delay.h>
 267 #include <linux/pci.h>
 268
 269 #include <asm/io.h>
 270 #include <asm/uaccess.h>
 271
 272 #include <linux/isapnp.h>
 273
 274 #include "ixj.h"
 275
 276 #define TYPE(inode) (iminor(inode) >> 4)
 277 #define NUM(inode) (iminor(inode) & 0xf)
 278
 279 static int ixjdebug;
 280 static int hertz = HZ;
 281 static int samplerate = 100;
 282
 283 module_param(ixjdebug, int, 0);
 284
 285 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 286         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 287           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 288         { }
 289 };
 290
 291 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 292
 293 /************************************************************************
 294 *
 295 * ixjdebug meanings are now bit mapped instead of level based
 296 * Values can be or'ed together to turn on multiple messages
 297 *
 298 * bit  0 (0x0001) = any failure
 299 * bit  1 (0x0002) = general messages
 300 * bit  2 (0x0004) = POTS ringing related
 301 * bit  3 (0x0008) = PSTN events
 302 * bit  4 (0x0010) = PSTN Cadence state details
 303 * bit  5 (0x0020) = Tone detection triggers
 304 * bit  6 (0x0040) = Tone detection cadence details
 305 * bit  7 (0x0080) = ioctl tracking
 306 * bit  8 (0x0100) = signal tracking
 307 * bit  9 (0x0200) = CallerID generation details
 308 *
 309 ************************************************************************/
 310
 311 #ifdef IXJ_DYN_ALLOC
 312
 313 static IXJ *ixj[IXJMAX];
 314 #define get_ixj(b)      ixj[(b)]
 315
 316 /*
 317  *      Allocate a free IXJ device
 318  */
 319
 320 static IXJ *ixj_alloc()
 321 {
 322         for(cnt=0; cnt<IXJMAX; cnt++)
 323         {
 324                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 325                 {
 326                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 327                         if (j == NULL)
 328                                 return NULL;
 329                         ixj[cnt] = j;
 330                         return j;
 331                 }
 332         }
 333         return NULL;
 334 }
 335
 336 static void ixj_fsk_free(IXJ *j)
 337 {
 338         kfree(j->fskdata);
 339         j->fskdata = NULL;
 340 }
 341
 342 static void ixj_fsk_alloc(IXJ *j)
 343 {
 344         if(!j->fskdata) {
 345                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 346                 if (!j->fskdata) {
 347                         if(ixjdebug & 0x0200) {
 348                                 printk("IXJ phone%d - allocate failed\n", j->board);
 349                         }
 350                         return;
 351                 } else {
 352                         j->fsksize = 8000;
 353                         if(ixjdebug & 0x0200) {
 354                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 355                         }
 356                 }
 357         }
 358 }
 359
 360 #else
 361
 362 static IXJ ixj[IXJMAX];
 363 #define get_ixj(b)      (&ixj[(b)])
 364
 365 /*
 366  *      Allocate a free IXJ device
 367  */
 368
 369 static IXJ *ixj_alloc(void)
 370 {
 371         int cnt;
 372         for(cnt=0; cnt<IXJMAX; cnt++) {
 373                 if(!ixj[cnt].DSPbase)
 374                         return &ixj[cnt];
 375         }
 376         return NULL;
 377 }
 378
 379 static inline void ixj_fsk_free(IXJ *j) {;}
 380
 381 static inline void ixj_fsk_alloc(IXJ *j)
 382 {
 383         j->fsksize = 8000;
 384 }
 385
 386 #endif
 387
 388 #ifdef PERFMON_STATS
 389 #define ixj_perfmon(x)  ((x)++)
 390 #else
 391 #define ixj_perfmon(x)  do { } while(0)
 392 #endif
 393
 394 static int ixj_convert_loaded;
 395
 396 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 397
 398 /************************************************************************
 399 *
 400 * These are function definitions to allow external modules to register
 401 * enhanced functionality call backs.
 402 *
 403 ************************************************************************/
 404
 405 static int Stub(IXJ * J, unsigned long arg)
 406 {
 407         return 0;
 408 }
 409
 410 static IXJ_REGFUNC ixj_PreRead = &Stub;
 411 static IXJ_REGFUNC ixj_PostRead = &Stub;
 412 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 413 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 414
 415 static void ixj_read_frame(IXJ *j);
 416 static void ixj_write_frame(IXJ *j);
 417 static void ixj_init_timer(IXJ *j);
 418 static void ixj_add_timer(IXJ * j);
 419 static void ixj_timeout(unsigned long ptr);
 420 static int read_filters(IXJ *j);
 421 static int LineMonitor(IXJ *j);
 422 static int ixj_fasync(int fd, struct file *, int mode);
 423 static int ixj_set_port(IXJ *j, int arg);
 424 static int ixj_set_pots(IXJ *j, int arg);
 425 static int ixj_hookstate(IXJ *j);
 426 static int ixj_record_start(IXJ *j);
 427 static void ixj_record_stop(IXJ *j);
 428 static void set_rec_volume(IXJ *j, int volume);
 429 static int get_rec_volume(IXJ *j);
 430 static int set_rec_codec(IXJ *j, int rate);
 431 static void ixj_vad(IXJ *j, int arg);
 432 static int ixj_play_start(IXJ *j);
 433 static void ixj_play_stop(IXJ *j);
 434 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 435 static int ixj_set_tone_off(unsigned short, IXJ *j);
 436 static int ixj_play_tone(IXJ *j, char tone);
 437 static void ixj_aec_start(IXJ *j, int level);
 438 static int idle(IXJ *j);
 439 static void ixj_ring_on(IXJ *j);
 440 static void ixj_ring_off(IXJ *j);
 441 static void aec_stop(IXJ *j);
 442 static void ixj_ringback(IXJ *j);
 443 static void ixj_busytone(IXJ *j);
 444 static void ixj_dialtone(IXJ *j);
 445 static void ixj_cpt_stop(IXJ *j);
 446 static char daa_int_read(IXJ *j);
 447 static char daa_CR_read(IXJ *j, int cr);
 448 static int daa_set_mode(IXJ *j, int mode);
 449 static int ixj_linetest(IXJ *j);
 450 static int ixj_daa_write(IXJ *j);
 451 static int ixj_daa_cid_read(IXJ *j);
 452 static void DAA_Coeff_US(IXJ *j);
 453 static void DAA_Coeff_UK(IXJ *j);
 454 static void DAA_Coeff_France(IXJ *j);
 455 static void DAA_Coeff_Germany(IXJ *j);
 456 static void DAA_Coeff_Australia(IXJ *j);
 457 static void DAA_Coeff_Japan(IXJ *j);
 458 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 459 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 460 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 461 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 462 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 463 /* Serial Control Interface funtions */
 464 static int SCI_Control(IXJ *j, int control);
 465 static int SCI_Prepare(IXJ *j);
 466 static int SCI_WaitHighSCI(IXJ *j);
 467 static int SCI_WaitLowSCI(IXJ *j);
 468 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 469 static int ixj_PCcontrol_wait(IXJ *j);
 470 static void ixj_pre_cid(IXJ *j);
 471 static void ixj_write_cid(IXJ *j);
 472 static void ixj_write_cid_bit(IXJ *j, int bit);
 473 static int set_base_frame(IXJ *j, int size);
 474 static int set_play_codec(IXJ *j, int rate);
 475 static void set_rec_depth(IXJ *j, int depth);
 476 static int ixj_mixer(long val, IXJ *j);
 477
 478 /************************************************************************
 479 CT8020/CT8021 Host Programmers Model
 480 Host address    Function                                        Access
 481 DSPbase +
 482 0-1             Aux Software Status Register (reserved)         Read Only
 483 2-3             Software Status Register                        Read Only
 484 4-5             Aux Software Control Register (reserved)        Read Write
 485 6-7             Software Control Register                       Read Write
 486 8-9             Hardware Status Register                        Read Only
 487 A-B             Hardware Control Register                       Read Write
 488 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 489 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 490 ************************************************************************/
 491
 492 static inline void ixj_read_HSR(IXJ *j)
 493 {
 494         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 495         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 496 }
 497
 498 static inline int IsControlReady(IXJ *j)
 499 {
 500         ixj_read_HSR(j);
 501         return j->hsr.bits.controlrdy ? 1 : 0;
 502 }
 503
 504 static inline int IsPCControlReady(IXJ *j)
 505 {
 506         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 507         return j->pccr1.bits.crr ? 1 : 0;
 508 }
 509
 510 static inline int IsStatusReady(IXJ *j)
 511 {
 512         ixj_read_HSR(j);
 513         return j->hsr.bits.statusrdy ? 1 : 0;
 514 }
 515
 516 static inline int IsRxReady(IXJ *j)
 517 {
 518         ixj_read_HSR(j);
 519         ixj_perfmon(j->rxreadycheck);
 520         return j->hsr.bits.rxrdy ? 1 : 0;
 521 }
 522
 523 static inline int IsTxReady(IXJ *j)
 524 {
 525         ixj_read_HSR(j);
 526         ixj_perfmon(j->txreadycheck);
 527         return j->hsr.bits.txrdy ? 1 : 0;
 528 }
 529
 530 static inline void set_play_volume(IXJ *j, int volume)
 531 {
 532         if (ixjdebug & 0x0002)
 533                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 534         ixj_WriteDSPCommand(0xCF02, j);
 535         ixj_WriteDSPCommand(volume, j);
 536 }
 537
 538 static int set_play_volume_linear(IXJ *j, int volume)
 539 {
 540         int newvolume, dspplaymax;
 541
 542         if (ixjdebug & 0x0002)
 543                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 544         if(volume > 100 || volume < 0) {
 545                 return -1;
 546         }
 547
 548         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 549         switch (j->cardtype) {
 550         case QTI_PHONEJACK:
 551                 dspplaymax = 0x380;
 552                 break;
 553         case QTI_LINEJACK:
 554                 if(j->port == PORT_PSTN) {
 555                         dspplaymax = 0x48;
 556                 } else {
 557                         dspplaymax = 0x100;
 558                 }
 559                 break;
 560         case QTI_PHONEJACK_LITE:
 561                 dspplaymax = 0x380;
 562                 break;
 563         case QTI_PHONEJACK_PCI:
 564                 dspplaymax = 0x6C;
 565                 break;
 566         case QTI_PHONECARD:
 567                 dspplaymax = 0x50;
 568                 break;
 569         default:
 570                 return -1;
 571         }
 572         newvolume = (dspplaymax * volume) / 100;
 573         set_play_volume(j, newvolume);
 574         return 0;
 575 }
 576
 577 static inline void set_play_depth(IXJ *j, int depth)
 578 {
 579         if (depth > 60)
 580                 depth = 60;
 581         if (depth < 0)
 582                 depth = 0;
 583         ixj_WriteDSPCommand(0x5280 + depth, j);
 584 }
 585
 586 static inline int get_play_volume(IXJ *j)
 587 {
 588         ixj_WriteDSPCommand(0xCF00, j);
 589         return j->ssr.high << 8 | j->ssr.low;
 590 }
 591
 592 static int get_play_volume_linear(IXJ *j)
 593 {
 594         int volume, newvolume, dspplaymax;
 595
 596         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 597         switch (j->cardtype) {
 598         case QTI_PHONEJACK:
 599                 dspplaymax = 0x380;
 600                 break;
 601         case QTI_LINEJACK:
 602                 if(j->port == PORT_PSTN) {
 603                         dspplaymax = 0x48;
 604                 } else {
 605                         dspplaymax = 0x100;
 606                 }
 607                 break;
 608         case QTI_PHONEJACK_LITE:
 609                 dspplaymax = 0x380;
 610                 break;
 611         case QTI_PHONEJACK_PCI:
 612                 dspplaymax = 0x6C;
 613                 break;
 614         case QTI_PHONECARD:
 615                 dspplaymax = 100;
 616                 break;
 617         default:
 618                 return -1;
 619         }
 620         volume = get_play_volume(j);
 621         newvolume = (volume * 100) / dspplaymax;
 622         if(newvolume > 100)
 623                 newvolume = 100;
 624         return newvolume;
 625 }
 626
 627 static inline BYTE SLIC_GetState(IXJ *j)
 628 {
 629         if (j->cardtype == QTI_PHONECARD) {
 630                 j->pccr1.byte = 0;
 631                 j->psccr.bits.dev = 3;
 632                 j->psccr.bits.rw = 1;
 633                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 634                 ixj_PCcontrol_wait(j);
 635                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 636                 ixj_PCcontrol_wait(j);
 637                 if (j->pslic.bits.powerdown)
 638                         return PLD_SLIC_STATE_OC;
 639                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 640                         return PLD_SLIC_STATE_ACTIVE;
 641                 else
 642                         return PLD_SLIC_STATE_RINGING;
 643         } else {
 644                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 645         }
 646         return j->pld_slicr.bits.state;
 647 }
 648
 649 static bool SLIC_SetState(BYTE byState, IXJ *j)
 650 {
 651         bool fRetVal = false;
 652
 653         if (j->cardtype == QTI_PHONECARD) {
 654                 if (j->flags.pcmciasct) {
 655                         switch (byState) {
 656                         case PLD_SLIC_STATE_TIPOPEN:
 657                         case PLD_SLIC_STATE_OC:
 658                                 j->pslic.bits.powerdown = 1;
 659                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 660                                 fRetVal = true;
 661                                 break;
 662                         case PLD_SLIC_STATE_RINGING:
 663                                 if (j->readers || j->writers) {
 664                                         j->pslic.bits.powerdown = 0;
 665                                         j->pslic.bits.ring0 = 1;
 666                                         j->pslic.bits.ring1 = 0;
 667                                         fRetVal = true;
 668                                 }
 669                                 break;
 670                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 671
 672                         case PLD_SLIC_STATE_STANDBY:
 673                         case PLD_SLIC_STATE_ACTIVE:
 674                                 if (j->readers || j->writers) {
 675                                         j->pslic.bits.powerdown = 0;
 676                                 } else {
 677                                         j->pslic.bits.powerdown = 1;
 678                                 }
 679                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 680                                 fRetVal = true;
 681                                 break;
 682                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 683
 684                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 685
 686                         default:
 687                                 fRetVal = false;
 688                                 break;
 689                         }
 690                         j->psccr.bits.dev = 3;
 691                         j->psccr.bits.rw = 0;
 692                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 693                         ixj_PCcontrol_wait(j);
 694                 }
 695         } else {
 696                 /* Set the C1, C2, C3 & B2EN signals. */
 697                 switch (byState) {
 698                 case PLD_SLIC_STATE_OC:
 699                         j->pld_slicw.bits.c1 = 0;
 700                         j->pld_slicw.bits.c2 = 0;
 701                         j->pld_slicw.bits.c3 = 0;
 702                         j->pld_slicw.bits.b2en = 0;
 703                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 704                         fRetVal = true;
 705                         break;
 706                 case PLD_SLIC_STATE_RINGING:
 707                         j->pld_slicw.bits.c1 = 1;
 708                         j->pld_slicw.bits.c2 = 0;
 709                         j->pld_slicw.bits.c3 = 0;
 710                         j->pld_slicw.bits.b2en = 1;
 711                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 712                         fRetVal = true;
 713                         break;
 714                 case PLD_SLIC_STATE_ACTIVE:
 715                         j->pld_slicw.bits.c1 = 0;
 716                         j->pld_slicw.bits.c2 = 1;
 717                         j->pld_slicw.bits.c3 = 0;
 718                         j->pld_slicw.bits.b2en = 0;
 719                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 720                         fRetVal = true;
 721                         break;
 722                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 723
 724                         j->pld_slicw.bits.c1 = 1;
 725                         j->pld_slicw.bits.c2 = 1;
 726                         j->pld_slicw.bits.c3 = 0;
 727                         j->pld_slicw.bits.b2en = 0;
 728                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 729                         fRetVal = true;
 730                         break;
 731                 case PLD_SLIC_STATE_TIPOPEN:
 732                         j->pld_slicw.bits.c1 = 0;
 733                         j->pld_slicw.bits.c2 = 0;
 734                         j->pld_slicw.bits.c3 = 1;
 735                         j->pld_slicw.bits.b2en = 0;
 736                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 737                         fRetVal = true;
 738                         break;
 739                 case PLD_SLIC_STATE_STANDBY:
 740                         j->pld_slicw.bits.c1 = 1;
 741                         j->pld_slicw.bits.c2 = 0;
 742                         j->pld_slicw.bits.c3 = 1;
 743                         j->pld_slicw.bits.b2en = 1;
 744                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 745                         fRetVal = true;
 746                         break;
 747                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 748
 749                         j->pld_slicw.bits.c1 = 0;
 750                         j->pld_slicw.bits.c2 = 1;
 751                         j->pld_slicw.bits.c3 = 1;
 752                         j->pld_slicw.bits.b2en = 0;
 753                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 754                         fRetVal = true;
 755                         break;
 756                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 757
 758                         j->pld_slicw.bits.c1 = 1;
 759                         j->pld_slicw.bits.c2 = 1;
 760                         j->pld_slicw.bits.c3 = 1;
 761                         j->pld_slicw.bits.b2en = 0;
 762                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 763                         fRetVal = true;
 764                         break;
 765                 default:
 766                         fRetVal = false;
 767                         break;
 768                 }
 769         }
 770
 771         return fRetVal;
 772 }
 773
 774 static int ixj_wink(IXJ *j)
 775 {
 776         BYTE slicnow;
 777
 778         slicnow = SLIC_GetState(j);
 779
 780         j->pots_winkstart = jiffies;
 781         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 782
 783         msleep(jiffies_to_msecs(j->winktime));
 784
 785         SLIC_SetState(slicnow, j);
 786         return 0;
 787 }
 788
 789 static void ixj_init_timer(IXJ *j)
 790 {
 791         init_timer(&j->timer);
 792         j->timer.function = ixj_timeout;
 793         j->timer.data = (unsigned long)j;
 794 }
 795
 796 static void ixj_add_timer(IXJ *j)
 797 {
 798         j->timer.expires = jiffies + (hertz / samplerate);
 799         add_timer(&j->timer);
 800 }
 801
 802 static void ixj_tone_timeout(IXJ *j)
 803 {
 804         IXJ_TONE ti;
 805
 806         j->tone_state++;
 807         if (j->tone_state == 3) {
 808                 j->tone_state = 0;
 809                 if (j->cadence_t) {
 810                         j->tone_cadence_state++;
 811                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 812                                 switch (j->cadence_t->termination) {
 813                                 case PLAY_ONCE:
 814                                         ixj_cpt_stop(j);
 815                                         break;
 816                                 case REPEAT_LAST_ELEMENT:
 817                                         j->tone_cadence_state--;
 818                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 819                                         break;
 820                                 case REPEAT_ALL:
 821                                         j->tone_cadence_state = 0;
 822                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 823                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 824                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 825                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 826                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 827                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 828                                                 ixj_init_tone(j, &ti);
 829                                         }
 830                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 831                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 832                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 833                                         break;
 834                                 }
 835                         } else {
 836                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 837                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 838                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 839                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 840                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 841                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 842                                         ixj_init_tone(j, &ti);
 843                                 }
 844                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 845                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 846                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 847                         }
 848                 }
 849         }
 850 }
 851
 852 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 853 {
 854         if(j->ixj_signals[event]) {
 855                 if(ixjdebug & 0x0100)
 856                         printk("Sending signal for event %d\n", event);
 857                         /* Send apps notice of change */
 858                 /* see config.h for macro definition */
 859                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 860         }
 861 }
 862
 863 static void ixj_pstn_state(IXJ *j)
 864 {
 865         int var;
 866         union XOPXR0 XR0, daaint;
 867
 868         var = 10;
 869
 870         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 871         daaint.reg = 0;
 872         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 873
 874         j->pld_scrr.byte = inb_p(j->XILINXbase);
 875         if (j->pld_scrr.bits.daaflag) {
 876                 daa_int_read(j);
 877                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 878                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 879                                 daaint.bitreg.RING = 1;
 880                                 if(ixjdebug & 0x0008) {
 881                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 882                                 }
 883                         } else {
 884                                 daa_set_mode(j, SOP_PU_RESET);
 885                         }
 886                 }
 887                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 888                         daaint.bitreg.Caller_ID = 1;
 889                         j->pstn_cid_intr = 1;
 890                         j->pstn_cid_received = jiffies;
 891                         if(ixjdebug & 0x0008) {
 892                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 893                         }
 894                 }
 895                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 896                         daaint.bitreg.Cadence = 1;
 897                         if(ixjdebug & 0x0008) {
 898                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 899                         }
 900                 }
 901                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 902                         daaint.bitreg.VDD_OK = 1;
 903                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 904                 }
 905         }
 906         daa_CR_read(j, 1);
 907         if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 908                 daaint.bitreg.RMR = 1;
 909                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 910                 if(ixjdebug & 0x0008) {
 911                         printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
 912                 }
 913                 j->pstn_prev_rmr = j->pstn_last_rmr;
 914                 j->pstn_last_rmr = jiffies;
 915         }
 916         switch(j->daa_mode) {
 917                 case SOP_PU_SLEEP:
 918                         if (daaint.bitreg.RING) {
 919                                 if (!j->flags.pstn_ringing) {
 920                                         if (j->daa_mode != SOP_PU_RINGING) {
 921                                                 j->pstn_ring_int = jiffies;
 922                                                 daa_set_mode(j, SOP_PU_RINGING);
 923                                         }
 924                                 }
 925                         }
 926                         break;
 927                 case SOP_PU_RINGING:
 928                         if (daaint.bitreg.RMR) {
 929                                 if (ixjdebug & 0x0008) {
 930                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 931                                 }
 932                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 933                                         j->flags.pstn_rmr = 1;
 934                                         j->pstn_ring_start = jiffies;
 935                                         j->pstn_ring_stop = 0;
 936                                         j->ex.bits.pstn_ring = 0;
 937                                         if (j->cadence_f[4].state == 0) {
 938                                                 j->cadence_f[4].state = 1;
 939                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 940                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 941                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 942                                         } else if (j->cadence_f[4].state == 2) {
 943                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 944                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 945                                                         if (j->cadence_f[4].on2) {
 946                                                                 j->cadence_f[4].state = 3;
 947                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 948                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 949                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 950                                                         } else {
 951                                                                 j->cadence_f[4].state = 7;
 952                                                         }
 953                                                 } else {
 954                                                         if (ixjdebug & 0x0008) {
 955                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 956                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 957                                                                                 j->cadence_f[4].off1);
 958                                                         }
 959                                                         j->cadence_f[4].state = 0;
 960                                                 }
 961                                         } else if (j->cadence_f[4].state == 4) {
 962                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 963                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 964                                                         if (j->cadence_f[4].on3) {
 965                                                                 j->cadence_f[4].state = 5;
 966                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 967                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 968                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 969                                                         } else {
 970                                                                 j->cadence_f[4].state = 7;
 971                                                         }
 972                                                 } else {
 973                                                         if (ixjdebug & 0x0008) {
 974                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 975                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 976                                                                                 j->cadence_f[4].off2);
 977                                                         }
 978                                                         j->cadence_f[4].state = 0;
 979                                                 }
 980                                         } else if (j->cadence_f[4].state == 6) {
 981                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 982                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 983                                                         j->cadence_f[4].state = 7;
 984                                                 } else {
 985                                                         if (ixjdebug & 0x0008) {
 986                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 987                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 988                                                                                 j->cadence_f[4].off3);
 989                                                         }
 990                                                         j->cadence_f[4].state = 0;
 991                                                 }
 992                                         } else {
 993                                                 j->cadence_f[4].state = 0;
 994                                         }
 995                                 } else {                                /* Falling edge of RMR */
 996                                         j->pstn_ring_start = 0;
 997                                         j->pstn_ring_stop = jiffies;
 998                                         if (j->cadence_f[4].state == 1) {
 999                                                 if(!j->cadence_f[4].on1) {
1000                                                         j->cadence_f[4].state = 7;
1001                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1002                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1003                                                         if (j->cadence_f[4].off1) {
1004                                                                 j->cadence_f[4].state = 2;
1005                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1006                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1007                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1008                                                         } else {
1009                                                                 j->cadence_f[4].state = 7;
1010                                                         }
1011                                                 } else {
1012                                                         if (ixjdebug & 0x0008) {
1013                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1014                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1015                                                                                 j->cadence_f[4].on1);
1016                                                         }
1017                                                         j->cadence_f[4].state = 0;
1018                                                 }
1019                                         } else if (j->cadence_f[4].state == 3) {
1020                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1021                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1022                                                         if (j->cadence_f[4].off2) {
1023                                                                 j->cadence_f[4].state = 4;
1024                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1025                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1026                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1027                                                         } else {
1028                                                                 j->cadence_f[4].state = 7;
1029                                                         }
1030                                                 } else {
1031                                                         if (ixjdebug & 0x0008) {
1032                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1033                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1034                                                                                 j->cadence_f[4].on2);
1035                                                         }
1036                                                         j->cadence_f[4].state = 0;
1037                                                 }
1038                                         } else if (j->cadence_f[4].state == 5) {
1039                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1040                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1041                                                         if (j->cadence_f[4].off3) {
1042                                                                 j->cadence_f[4].state = 6;
1043                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1044                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1045                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1046                                                         } else {
1047                                                                 j->cadence_f[4].state = 7;
1048                                                         }
1049                                                 } else {
1050                                                         j->cadence_f[4].state = 0;
1051                                                 }
1052                                         } else {
1053                                                 if (ixjdebug & 0x0008) {
1054                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1055                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1056                                                                         j->cadence_f[4].on3);
1057                                                 }
1058                                                 j->cadence_f[4].state = 0;
1059                                         }
1060                                 }
1061                                 if (ixjdebug & 0x0010) {
1062                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1063                                 }
1064                                 if (ixjdebug & 0x0010) {
1065                                         switch(j->cadence_f[4].state) {
1066                                                 case 1:
1067                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1068                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1069                                                         break;
1070                                                 case 2:
1071                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1072                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1073                                                         break;
1074                                                 case 3:
1075                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1076                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1077                                                         break;
1078                                                 case 4:
1079                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1080                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1081                                                         break;
1082                                                 case 5:
1083                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1084                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1085                                                         break;
1086                                                 case 6:
1087                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1088                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1089                                                         break;
1090                                         }
1091                                 }
1092                         }
1093                         if (j->cadence_f[4].state == 7) {
1094                                 j->cadence_f[4].state = 0;
1095                                 j->pstn_ring_stop = jiffies;
1096                                 j->ex.bits.pstn_ring = 1;
1097                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1098                                 if(ixjdebug & 0x0008) {
1099                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1100                                 }
1101                         }
1102                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1103                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1104                                 if(ixjdebug & 0x0008) {
1105                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1106                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1107                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1108                                 }
1109                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1110                                 daa_set_mode(j, SOP_PU_SLEEP);
1111                         }
1112                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1113                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1114                                 ixj_daa_cid_read(j);
1115                                 j->ex.bits.caller_id = 1;
1116                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1117                                 j->pstn_cid_intr = 0;
1118                         }
1119                         if (daaint.bitreg.Cadence) {
1120                                 if(ixjdebug & 0x0008) {
1121                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1122                                 }
1123                                 daa_set_mode(j, SOP_PU_SLEEP);
1124                                 j->ex.bits.pstn_ring = 0;
1125                         }
1126                         break;
1127                 case SOP_PU_CONVERSATION:
1128                         if (daaint.bitreg.VDD_OK) {
1129                                 if(!daaint.bitreg.SI_0) {
1130                                         if (!j->pstn_winkstart) {
1131                                                 if(ixjdebug & 0x0008) {
1132                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1133                                                 }
1134                                                 j->pstn_winkstart = jiffies;
1135                                         }
1136                                 } else {
1137                                         if (j->pstn_winkstart) {
1138                                                 if(ixjdebug & 0x0008) {
1139                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1140                                                 }
1141                                                 j->pstn_winkstart = 0;
1142                                         }
1143                                 }
1144                         }
1145                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1146                                 if(ixjdebug & 0x0008) {
1147                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1148                                 }
1149                                 daa_set_mode(j, SOP_PU_SLEEP);
1150                                 j->pstn_winkstart = 0;
1151                                 j->ex.bits.pstn_wink = 1;
1152                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1153                         }
1154                         break;
1155         }
1156 }
1157
1158 static void ixj_timeout(unsigned long ptr)
1159 {
1160         int board;
1161         unsigned long jifon;
1162         IXJ *j = (IXJ *)ptr;
1163         board = j->board;
1164
1165         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1166                 ixj_perfmon(j->timerchecks);
1167                 j->hookstate = ixj_hookstate(j);
1168                 if (j->tone_state) {
1169                         if (!(j->hookstate)) {
1170                                 ixj_cpt_stop(j);
1171                                 if (j->m_hook) {
1172                                         j->m_hook = 0;
1173                                         j->ex.bits.hookstate = 1;
1174                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1175                                 }
1176                                 clear_bit(board, &j->busyflags);
1177                                 ixj_add_timer(j);
1178                                 return;
1179                         }
1180                         if (j->tone_state == 1)
1181                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1182                         else
1183                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1184                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1185                                 if (j->tone_state == 1) {
1186                                         ixj_play_tone(j, j->tone_index);
1187                                         if (j->dsp.low == 0x20) {
1188                                                 clear_bit(board, &j->busyflags);
1189                                                 ixj_add_timer(j);
1190                                                 return;
1191                                         }
1192                                 } else {
1193                                         ixj_play_tone(j, 0);
1194                                         if (j->dsp.low == 0x20) {
1195                                                 clear_bit(board, &j->busyflags);
1196                                                 ixj_add_timer(j);
1197                                                 return;
1198                                         }
1199                                 }
1200                         } else {
1201                                 ixj_tone_timeout(j);
1202                                 if (j->flags.dialtone) {
1203                                         ixj_dialtone(j);
1204                                 }
1205                                 if (j->flags.busytone) {
1206                                         ixj_busytone(j);
1207                                         if (j->dsp.low == 0x20) {
1208                                                 clear_bit(board, &j->busyflags);
1209                                                 ixj_add_timer(j);
1210                                                 return;
1211                                         }
1212                                 }
1213                                 if (j->flags.ringback) {
1214                                         ixj_ringback(j);
1215                                         if (j->dsp.low == 0x20) {
1216                                                 clear_bit(board, &j->busyflags);
1217                                                 ixj_add_timer(j);
1218                                                 return;
1219                                         }
1220                                 }
1221                                 if (!j->tone_state) {
1222                                         ixj_cpt_stop(j);
1223                                 }
1224                         }
1225                 }
1226                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1227                         if (IsRxReady(j)) {
1228                                 ixj_read_frame(j);
1229                         }
1230                         if (IsTxReady(j)) {
1231                                 ixj_write_frame(j);
1232                         }
1233                 }
1234                 if (j->flags.cringing) {
1235                         if (j->hookstate & 1) {
1236                                 j->flags.cringing = 0;
1237                                 ixj_ring_off(j);
1238                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1239                                 switch(j->cadence_f[5].state) {
1240                                         case 0:
1241                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1242                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1243                                                         if(ixjdebug & 0x0004) {
1244                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1245                                                         }
1246                                                         ixj_ring_on(j);
1247                                                 }
1248                                                 j->cadence_f[5].state = 1;
1249                                                 break;
1250                                         case 1:
1251                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1252                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1253                                                         if(ixjdebug & 0x0004) {
1254                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1255                                                         }
1256                                                         ixj_ring_off(j);
1257                                                         j->cadence_f[5].state = 2;
1258                                                 }
1259                                                 break;
1260                                         case 2:
1261                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1262                                                         if(ixjdebug & 0x0004) {
1263                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1264                                                         }
1265                                                         ixj_ring_on(j);
1266                                                         if (j->cadence_f[5].on2) {
1267                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1268                                                                 j->cadence_f[5].state = 3;
1269                                                         } else {
1270                                                                 j->cadence_f[5].state = 7;
1271                                                         }
1272                                                 }
1273                                                 break;
1274                                         case 3:
1275                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1276                                                         if(ixjdebug & 0x0004) {
1277                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1278                                                         }
1279                                                         ixj_ring_off(j);
1280                                                         if (j->cadence_f[5].off2) {
1281                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1282                                                                 j->cadence_f[5].state = 4;
1283                                                         } else {
1284                                                                 j->cadence_f[5].state = 7;
1285                                                         }
1286                                                 }
1287                                                 break;
1288                                         case 4:
1289                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1290                                                         if(ixjdebug & 0x0004) {
1291                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1292                                                         }
1293                                                         ixj_ring_on(j);
1294                                                         if (j->cadence_f[5].on3) {
1295                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1296                                                                 j->cadence_f[5].state = 5;
1297                                                         } else {
1298                                                                 j->cadence_f[5].state = 7;
1299                                                         }
1300                                                 }
1301                                                 break;
1302                                         case 5:
1303                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1304                                                         if(ixjdebug & 0x0004) {
1305                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1306                                                         }
1307                                                         ixj_ring_off(j);
1308                                                         if (j->cadence_f[5].off3) {
1309                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1310                                                                 j->cadence_f[5].state = 6;
1311                                                         } else {
1312                                                                 j->cadence_f[5].state = 7;
1313                                                         }
1314                                                 }
1315                                                 break;
1316                                         case 6:
1317                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1318                                                         if(ixjdebug & 0x0004) {
1319                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1320                                                         }
1321                                                         j->cadence_f[5].state = 7;
1322                                                 }
1323                                                 break;
1324                                         case 7:
1325                                                 if(ixjdebug & 0x0004) {
1326                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1327                                                 }
1328                                                 j->flags.cidring = 1;
1329                                                 j->cadence_f[5].state = 0;
1330                                                 break;
1331                                 }
1332                                 if (j->flags.cidring && !j->flags.cidsent) {
1333                                         j->flags.cidsent = 1;
1334                                         if(j->fskdcnt) {
1335                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1336                                                 ixj_pre_cid(j);
1337                                         }
1338                                         j->flags.cidring = 0;
1339                                 }
1340                                 clear_bit(board, &j->busyflags);
1341                                 ixj_add_timer(j);
1342                                 return;
1343                         } else {
1344                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1345                                         if (j->flags.cidring && !j->flags.cidsent) {
1346                                                 j->flags.cidsent = 1;
1347                                                 if(j->fskdcnt) {
1348                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1349                                                         ixj_pre_cid(j);
1350                                                 }
1351                                                 j->flags.cidring = 0;
1352                                         }
1353                                         j->ring_cadence_t--;
1354                                         if (j->ring_cadence_t == -1)
1355                                                 j->ring_cadence_t = 15;
1356                                         j->ring_cadence_jif = jiffies;
1357
1358                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1359                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1360                                                         j->flags.firstring = 1;
1361                                                 else
1362                                                         ixj_ring_on(j);
1363                                         } else {
1364                                                 ixj_ring_off(j);
1365                                                 if(!j->flags.cidsent)
1366                                                         j->flags.cidring = 1;
1367                                         }
1368                                 }
1369                                 clear_bit(board, &j->busyflags);
1370                                 ixj_add_timer(j);
1371                                 return;
1372                         }
1373                 }
1374                 if (!j->flags.ringing) {
1375                         if (j->hookstate) { /* & 1) { */
1376                                 if (j->dsp.low != 0x20 &&
1377                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1378                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1379                                 }
1380                                 LineMonitor(j);
1381                                 read_filters(j);
1382                                 ixj_WriteDSPCommand(0x511B, j);
1383                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1384                                 if (!j->m_hook && (j->hookstate & 1)) {
1385                                         j->m_hook = j->ex.bits.hookstate = 1;
1386                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1387                                 }
1388                         } else {
1389                                 if (j->ex.bits.dtmf_ready) {
1390                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1391                                 }
1392                                 if (j->m_hook) {
1393                                         j->m_hook = 0;
1394                                         j->ex.bits.hookstate = 1;
1395                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1396                                 }
1397                         }
1398                 }
1399                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1400                         ixj_pstn_state(j);
1401                 }
1402                 if (j->ex.bytes) {
1403                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1404                 }
1405                 clear_bit(board, &j->busyflags);
1406         }
1407         ixj_add_timer(j);
1408 }
1409
1410 static int ixj_status_wait(IXJ *j)
1411 {
1412         unsigned long jif;
1413
1414         jif = jiffies + ((60 * hertz) / 100);
1415         while (!IsStatusReady(j)) {
1416                 ixj_perfmon(j->statuswait);
1417                 if (time_after(jiffies, jif)) {
1418                         ixj_perfmon(j->statuswaitfail);
1419                         return -1;
1420                 }
1421         }
1422         return 0;
1423 }
1424
1425 static int ixj_PCcontrol_wait(IXJ *j)
1426 {
1427         unsigned long jif;
1428
1429         jif = jiffies + ((60 * hertz) / 100);
1430         while (!IsPCControlReady(j)) {
1431                 ixj_perfmon(j->pcontrolwait);
1432                 if (time_after(jiffies, jif)) {
1433                         ixj_perfmon(j->pcontrolwaitfail);
1434                         return -1;
1435                 }
1436         }
1437         return 0;
1438 }
1439
1440 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1441 {
1442         BYTES bytes;
1443         unsigned long jif;
1444
1445         atomic_inc(&j->DSPWrite);
1446         if(atomic_read(&j->DSPWrite) > 1) {
1447                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1448                 return -1;
1449         }
1450         bytes.high = (cmd & 0xFF00) >> 8;
1451         bytes.low = cmd & 0x00FF;
1452         jif = jiffies + ((60 * hertz) / 100);
1453         while (!IsControlReady(j)) {
1454                 ixj_perfmon(j->iscontrolready);
1455                 if (time_after(jiffies, jif)) {
1456                         ixj_perfmon(j->iscontrolreadyfail);
1457                         atomic_dec(&j->DSPWrite);
1458                         if(atomic_read(&j->DSPWrite) > 0) {
1459                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1460                                 while(atomic_read(&j->DSPWrite) > 0) {
1461                                         atomic_dec(&j->DSPWrite);
1462                                 }
1463                         }
1464                         return -1;
1465                 }
1466         }
1467         outb(bytes.low, j->DSPbase + 6);
1468         outb(bytes.high, j->DSPbase + 7);
1469
1470         if (ixj_status_wait(j)) {
1471                 j->ssr.low = 0xFF;
1472                 j->ssr.high = 0xFF;
1473                 atomic_dec(&j->DSPWrite);
1474                 if(atomic_read(&j->DSPWrite) > 0) {
1475                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1476                         while(atomic_read(&j->DSPWrite) > 0) {
1477                                 atomic_dec(&j->DSPWrite);
1478                         }
1479                 }
1480                 return -1;
1481         }
1482 /* Read Software Status Register */
1483         j->ssr.low = inb_p(j->DSPbase + 2);
1484         j->ssr.high = inb_p(j->DSPbase + 3);
1485         atomic_dec(&j->DSPWrite);
1486         if(atomic_read(&j->DSPWrite) > 0) {
1487                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1488                 while(atomic_read(&j->DSPWrite) > 0) {
1489                         atomic_dec(&j->DSPWrite);
1490                 }
1491         }
1492         return 0;
1493 }
1494
1495 /***************************************************************************
1496 *
1497 *  General Purpose IO Register read routine
1498 *
1499 ***************************************************************************/
1500 static inline int ixj_gpio_read(IXJ *j)
1501 {
1502         if (ixj_WriteDSPCommand(0x5143, j))
1503                 return -1;
1504
1505         j->gpio.bytes.low = j->ssr.low;
1506         j->gpio.bytes.high = j->ssr.high;
1507
1508         return 0;
1509 }
1510
1511 static inline void LED_SetState(int state, IXJ *j)
1512 {
1513         if (j->cardtype == QTI_LINEJACK) {
1514                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1515                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1516                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1517                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1518
1519                 outb(j->pld_scrw.byte, j->XILINXbase);
1520         }
1521 }
1522
1523 /*********************************************************************
1524 *  GPIO Pins are configured as follows on the Quicknet Internet
1525 *  PhoneJACK Telephony Cards
1526 *
1527 * POTS Select        GPIO_6=0 GPIO_7=0
1528 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1529 * Handset Select     GPIO_6=1 GPIO_7=0
1530 *
1531 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1532 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1533 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1534 *
1535 * Hook Switch changes reported on GPIO_3
1536 *********************************************************************/
1537 static int ixj_set_port(IXJ *j, int arg)
1538 {
1539         if (j->cardtype == QTI_PHONEJACK_LITE) {
1540                 if (arg != PORT_POTS)
1541                         return 10;
1542                 else
1543                         return 0;
1544         }
1545         switch (arg) {
1546         case PORT_POTS:
1547                 j->port = PORT_POTS;
1548                 switch (j->cardtype) {
1549                 case QTI_PHONECARD:
1550                         if (j->flags.pcmciasct == 1)
1551                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1552                         else
1553                                 return 11;
1554                         break;
1555                 case QTI_PHONEJACK_PCI:
1556                         j->pld_slicw.pcib.mic = 0;
1557                         j->pld_slicw.pcib.spk = 0;
1558                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1559                         break;
1560                 case QTI_LINEJACK:
1561                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1562                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1563                                                                            Software Control Register */
1564                                 return 2;
1565                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1566
1567                         outb(j->pld_scrw.byte, j->XILINXbase);
1568                         j->pld_clock.byte = 0;
1569                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1570                         j->pld_slicw.bits.rly1 = 1;
1571                         j->pld_slicw.bits.spken = 0;
1572                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1573                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1574                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1575                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1576                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1577                         ixj_mixer(0x0E80, j);   /*Mic mute */
1578                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1579                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1580                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1581                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1582 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1583                         break;
1584                 case QTI_PHONEJACK:
1585                         j->gpio.bytes.high = 0x0B;
1586                         j->gpio.bits.gpio6 = 0;
1587                         j->gpio.bits.gpio7 = 0;
1588                         ixj_WriteDSPCommand(j->gpio.word, j);
1589                         break;
1590                 }
1591                 break;
1592         case PORT_PSTN:
1593                 if (j->cardtype == QTI_LINEJACK) {
1594                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1595
1596                         j->pld_slicw.bits.rly3 = 0;
1597                         j->pld_slicw.bits.rly1 = 1;
1598                         j->pld_slicw.bits.spken = 0;
1599                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1600                         j->port = PORT_PSTN;
1601                 } else {
1602                         return 4;
1603                 }
1604                 break;
1605         case PORT_SPEAKER:
1606                 j->port = PORT_SPEAKER;
1607                 switch (j->cardtype) {
1608                 case QTI_PHONECARD:
1609                         if (j->flags.pcmciasct) {
1610                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1611                         }
1612                         break;
1613                 case QTI_PHONEJACK_PCI:
1614                         j->pld_slicw.pcib.mic = 1;
1615                         j->pld_slicw.pcib.spk = 1;
1616                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1617                         break;
1618                 case QTI_LINEJACK:
1619                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1620                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1621                                                                            Software Control Register */
1622                                 return 2;
1623                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1624
1625                         outb(j->pld_scrw.byte, j->XILINXbase);
1626                         j->pld_clock.byte = 0;
1627                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1628                         j->pld_slicw.bits.rly1 = 1;
1629                         j->pld_slicw.bits.spken = 1;
1630                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1631                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1632                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1633                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1634                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1635                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1636                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1637                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1638                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1639                         break;
1640                 case QTI_PHONEJACK:
1641                         j->gpio.bytes.high = 0x0B;
1642                         j->gpio.bits.gpio6 = 0;
1643                         j->gpio.bits.gpio7 = 1;
1644                         ixj_WriteDSPCommand(j->gpio.word, j);
1645                         break;
1646                 }
1647                 break;
1648         case PORT_HANDSET:
1649                 if (j->cardtype != QTI_PHONEJACK) {
1650                         return 5;
1651                 } else {
1652                         j->gpio.bytes.high = 0x0B;
1653                         j->gpio.bits.gpio6 = 1;
1654                         j->gpio.bits.gpio7 = 0;
1655                         ixj_WriteDSPCommand(j->gpio.word, j);
1656                         j->port = PORT_HANDSET;
1657                 }
1658                 break;
1659         default:
1660                 return 6;
1661                 break;
1662         }
1663         return 0;
1664 }
1665
1666 static int ixj_set_pots(IXJ *j, int arg)
1667 {
1668         if (j->cardtype == QTI_LINEJACK) {
1669                 if (arg) {
1670                         if (j->port == PORT_PSTN) {
1671                                 j->pld_slicw.bits.rly1 = 0;
1672                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1673                                 j->flags.pots_pstn = 1;
1674                                 return 1;
1675                         } else {
1676                                 j->flags.pots_pstn = 0;
1677                                 return 0;
1678                         }
1679                 } else {
1680                         j->pld_slicw.bits.rly1 = 1;
1681                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1682                         j->flags.pots_pstn = 0;
1683                         return 1;
1684                 }
1685         } else {
1686                 return 0;
1687         }
1688 }
1689
1690 static void ixj_ring_on(IXJ *j)
1691 {
1692         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1693          {
1694                 if (ixjdebug & 0x0004)
1695                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1696
1697                 j->gpio.bytes.high = 0x0B;
1698                 j->gpio.bytes.low = 0x00;
1699                 j->gpio.bits.gpio1 = 1;
1700                 j->gpio.bits.gpio2 = 1;
1701                 j->gpio.bits.gpio5 = 0;
1702                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1703         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1704         {
1705                 if (ixjdebug & 0x0004)
1706                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1707
1708                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1709         }
1710 }
1711
1712 static int ixj_siadc(IXJ *j, int val)
1713 {
1714         if(j->cardtype == QTI_PHONECARD){
1715                 if(j->flags.pcmciascp){
1716                         if(val == -1)
1717                                 return j->siadc.bits.rxg;
1718
1719                         if(val < 0 || val > 0x1F)
1720                                 return -1;
1721
1722                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1723                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1724                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1725                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1726                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1727                         j->psccr.bits.dev = 0;
1728                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1729                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1730                         ixj_PCcontrol_wait(j);
1731                         return j->siadc.bits.rxg;
1732                 }
1733         }
1734         return -1;
1735 }
1736
1737 static int ixj_sidac(IXJ *j, int val)
1738 {
1739         if(j->cardtype == QTI_PHONECARD){
1740                 if(j->flags.pcmciascp){
1741                         if(val == -1)
1742                                 return j->sidac.bits.txg;
1743
1744                         if(val < 0 || val > 0x1F)
1745                                 return -1;
1746
1747                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1748                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1749                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1750                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1751                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1752                         j->psccr.bits.dev = 0;
1753                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1754                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1755                         ixj_PCcontrol_wait(j);
1756                         return j->sidac.bits.txg;
1757                 }
1758         }
1759         return -1;
1760 }
1761
1762 static int ixj_pcmcia_cable_check(IXJ *j)
1763 {
1764         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1765         if (!j->flags.pcmciastate) {
1766                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1767                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1768                         j->flags.pcmciastate = 4;
1769                         return 0;
1770                 }
1771                 if (j->pccr1.bits.ed) {
1772                         j->pccr1.bits.ed = 0;
1773                         j->psccr.bits.dev = 3;
1774                         j->psccr.bits.rw = 1;
1775                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1776                         ixj_PCcontrol_wait(j);
1777                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1778                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1779                         j->psccr.bits.dev = 3;
1780                         j->psccr.bits.rw = 0;
1781                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1782                         ixj_PCcontrol_wait(j);
1783                         return j->pslic.bits.led2 ? 1 : 0;
1784                 } else if (j->flags.pcmciasct) {
1785                         return j->r_hook;
1786                 } else {
1787                         return 1;
1788                 }
1789         } else if (j->flags.pcmciastate == 4) {
1790                 if (!j->pccr1.bits.drf) {
1791                         j->flags.pcmciastate = 3;
1792                 }
1793                 return 0;
1794         } else if (j->flags.pcmciastate == 3) {
1795                 j->pccr2.bits.pwr = 0;
1796                 j->pccr2.bits.rstc = 1;
1797                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1798                 j->checkwait = jiffies + (hertz * 2);
1799                 j->flags.incheck = 1;
1800                 j->flags.pcmciastate = 2;
1801                 return 0;
1802         } else if (j->flags.pcmciastate == 2) {
1803                 if (j->flags.incheck) {
1804                         if (time_before(jiffies, j->checkwait)) {
1805                                 return 0;
1806                         } else {
1807                                 j->flags.incheck = 0;
1808                         }
1809                 }
1810                 j->pccr2.bits.pwr = 0;
1811                 j->pccr2.bits.rstc = 0;
1812                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1813                 j->flags.pcmciastate = 1;
1814                 return 0;
1815         } else if (j->flags.pcmciastate == 1) {
1816                 j->flags.pcmciastate = 0;
1817                 if (!j->pccr1.bits.drf) {
1818                         j->psccr.bits.dev = 3;
1819                         j->psccr.bits.rw = 1;
1820                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1821                         ixj_PCcontrol_wait(j);
1822                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1823
1824                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1825
1826                         if (j->flags.pcmciasct == 3) {
1827                                 j->flags.pcmciastate = 4;
1828                                 return 0;
1829                         } else if (j->flags.pcmciasct == 0) {
1830                                 j->pccr2.bits.pwr = 1;
1831                                 j->pccr2.bits.rstc = 0;
1832                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1833                                 j->port = PORT_SPEAKER;
1834                         } else {
1835                                 j->port = PORT_POTS;
1836                         }
1837                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1838                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1839                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1840                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1841                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1842                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1843                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1844                         j->psccr.bits.dev = 0;
1845                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1846                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1847                         ixj_PCcontrol_wait(j);
1848
1849                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1850                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1851                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1852                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1853                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1854                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1855                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1856                         j->psccr.bits.dev = 0;
1857                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1858                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1859                         ixj_PCcontrol_wait(j);
1860
1861                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1862                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1863                         j->psccr.bits.dev = 0;
1864                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1865                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1866                         ixj_PCcontrol_wait(j);
1867
1868                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1869                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1870                         j->psccr.bits.dev = 0;
1871                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1872                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1873                         ixj_PCcontrol_wait(j);
1874
1875                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1876                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1877                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1878                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1879                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1880                         j->sirxg.bits.iir = 1;                          /* IIR */
1881                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1882                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1883                         j->psccr.bits.dev = 0;
1884                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1885                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1886                         ixj_PCcontrol_wait(j);
1887
1888                         ixj_siadc(j, 0x17);
1889                         ixj_sidac(j, 0x1D);
1890
1891                         j->siaatt.bits.sot = 0;
1892                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1893                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1894                         j->psccr.bits.dev = 0;
1895                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1896                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1897                         ixj_PCcontrol_wait(j);
1898
1899                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1900                                 j->psccr.byte = j->pslic.byte = 0;
1901                                 j->pslic.bits.powerdown = 1;
1902                                 j->psccr.bits.dev = 3;
1903                                 j->psccr.bits.rw = 0;
1904                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1905                                 ixj_PCcontrol_wait(j);
1906                         }
1907                 }
1908                 return 0;
1909         } else {
1910                 j->flags.pcmciascp = 0;
1911                 return 0;
1912         }
1913         return 0;
1914 }
1915
1916 static int ixj_hookstate(IXJ *j)
1917 {
1918         int fOffHook = 0;
1919
1920         switch (j->cardtype) {
1921         case QTI_PHONEJACK:
1922                 ixj_gpio_read(j);
1923                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1924                 break;
1925         case QTI_LINEJACK:
1926         case QTI_PHONEJACK_LITE:
1927         case QTI_PHONEJACK_PCI:
1928                 SLIC_GetState(j);
1929                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1930                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1931                         if(fOffHook != j->p_hook) {
1932                                 if(!j->checkwait) {
1933                                         j->checkwait = jiffies;
1934                                 }
1935                                 if(time_before(jiffies, j->checkwait + 2)) {
1936                                         fOffHook ^= 1;
1937                                 } else {
1938                                         j->checkwait = 0;
1939                                 }
1940                                 j->p_hook = fOffHook;
1941                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1942                         }
1943                 } else {
1944                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1945                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1946                                 if (j->flags.ringing || j->flags.cringing) {
1947                                         if (!in_interrupt()) {
1948                                                 msleep(20);
1949                                         }
1950                                         SLIC_GetState(j);
1951                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1952                                                 ixj_ring_on(j);
1953                                         }
1954                                 }
1955                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1956                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1957                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1958                                 } else
1959                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1960                         }
1961                 }
1962                 break;
1963         case QTI_PHONECARD:
1964                 fOffHook = ixj_pcmcia_cable_check(j);
1965                 break;
1966         }
1967         if (j->r_hook != fOffHook) {
1968                 j->r_hook = fOffHook;
1969                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1970                         j->ex.bits.hookstate = 1;
1971                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1972                 } else if (!fOffHook) {
1973                         j->flash_end = jiffies + ((60 * hertz) / 100);
1974                 }
1975         }
1976         if (fOffHook) {
1977                 if(time_before(jiffies, j->flash_end)) {
1978                         j->ex.bits.flash = 1;
1979                         j->flash_end = 0;
1980                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1981                 }
1982         } else {
1983                 if(time_before(jiffies, j->flash_end)) {
1984                         fOffHook = 1;
1985                 }
1986         }
1987
1988         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1989                 fOffHook |= 2;
1990
1991         if (j->port == PORT_SPEAKER) {
1992                 if(j->cardtype == QTI_PHONECARD) {
1993                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1994                                 fOffHook |= 2;
1995                         }
1996                 } else {
1997                         fOffHook |= 2;
1998                 }
1999         }
2000
2001         if (j->port == PORT_HANDSET)
2002                 fOffHook |= 2;
2003
2004         return fOffHook;
2005 }
2006
2007 static void ixj_ring_off(IXJ *j)
2008 {
2009         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2010          {
2011                 if (ixjdebug & 0x0004)
2012                         printk(KERN_INFO "IXJ Ring Off\n");
2013                 j->gpio.bytes.high = 0x0B;
2014                 j->gpio.bytes.low = 0x00;
2015                 j->gpio.bits.gpio1 = 0;
2016                 j->gpio.bits.gpio2 = 1;
2017                 j->gpio.bits.gpio5 = 0;
2018                 ixj_WriteDSPCommand(j->gpio.word, j);
2019         } else                  /* Internet LineJACK */
2020         {
2021                 if (ixjdebug & 0x0004)
2022                         printk(KERN_INFO "IXJ Ring Off\n");
2023
2024                 if(!j->flags.cidplay)
2025                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2026
2027                 SLIC_GetState(j);
2028         }
2029 }
2030
2031 static void ixj_ring_start(IXJ *j)
2032 {
2033         j->flags.cringing = 1;
2034         if (ixjdebug & 0x0004)
2035                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2036         if (ixj_hookstate(j) & 1) {
2037                 if (j->port == PORT_POTS)
2038                         ixj_ring_off(j);
2039                 j->flags.cringing = 0;
2040                 if (ixjdebug & 0x0004)
2041                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2042         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2043                 j->ring_cadence_jif = jiffies;
2044                 j->flags.cidsent = j->flags.cidring = 0;
2045                 j->cadence_f[5].state = 0;
2046                 if(j->cadence_f[5].on1)
2047                         ixj_ring_on(j);
2048         } else {
2049                 j->ring_cadence_jif = jiffies;
2050                 j->ring_cadence_t = 15;
2051                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2052                         ixj_ring_on(j);
2053                 } else {
2054                         ixj_ring_off(j);
2055                 }
2056                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2057         }
2058 }
2059
2060 static int ixj_ring(IXJ *j)
2061 {
2062         char cntr;
2063         unsigned long jif;
2064
2065         j->flags.ringing = 1;
2066         if (ixj_hookstate(j) & 1) {
2067                 ixj_ring_off(j);
2068                 j->flags.ringing = 0;
2069                 return 1;
2070         }
2071         for (cntr = 0; cntr < j->maxrings; cntr++) {
2072                 jif = jiffies + (1 * hertz);
2073                 ixj_ring_on(j);
2074                 while (time_before(jiffies, jif)) {
2075                         if (ixj_hookstate(j) & 1) {
2076                                 ixj_ring_off(j);
2077                                 j->flags.ringing = 0;
2078                                 return 1;
2079                         }
2080                         schedule_timeout_interruptible(1);
2081                         if (signal_pending(current))
2082                                 break;
2083                 }
2084                 jif = jiffies + (3 * hertz);
2085                 ixj_ring_off(j);
2086                 while (time_before(jiffies, jif)) {
2087                         if (ixj_hookstate(j) & 1) {
2088                                 msleep(10);
2089                                 if (ixj_hookstate(j) & 1) {
2090                                         j->flags.ringing = 0;
2091                                         return 1;
2092                                 }
2093                         }
2094                         schedule_timeout_interruptible(1);
2095                         if (signal_pending(current))
2096                                 break;
2097                 }
2098         }
2099         ixj_ring_off(j);
2100         j->flags.ringing = 0;
2101         return 0;
2102 }
2103
2104 static int ixj_open(struct phone_device *p, struct file *file_p)
2105 {
2106         IXJ *j = get_ixj(p->board);
2107         file_p->private_data = j;
2108
2109         if (!j->DSPbase)
2110                 return -ENODEV;
2111
2112         if (file_p->f_mode & FMODE_READ) {
2113                 if(!j->readers) {
2114                         j->readers++;
2115                 } else {
2116                         return -EBUSY;
2117                 }
2118         }
2119
2120         if (file_p->f_mode & FMODE_WRITE) {
2121                 if(!j->writers) {
2122                         j->writers++;
2123                 } else {
2124                         if (file_p->f_mode & FMODE_READ){
2125                                 j->readers--;
2126                         }
2127                         return -EBUSY;
2128                 }
2129         }
2130
2131         if (j->cardtype == QTI_PHONECARD) {
2132                 j->pslic.bits.powerdown = 0;
2133                 j->psccr.bits.dev = 3;
2134                 j->psccr.bits.rw = 0;
2135                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2136                 ixj_PCcontrol_wait(j);
2137         }
2138
2139         j->flags.cidplay = 0;
2140         j->flags.cidcw_ack = 0;
2141
2142         if (ixjdebug & 0x0002)
2143                 printk(KERN_INFO "Opening board %d\n", p->board);
2144
2145         j->framesread = j->frameswritten = 0;
2146         return 0;
2147 }
2148
2149 static int ixj_release(struct inode *inode, struct file *file_p)
2150 {
2151         IXJ_TONE ti;
2152         int cnt;
2153         IXJ *j = file_p->private_data;
2154         int board = j->p.board;
2155
2156         /*
2157          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2158          *    This is necessary to keep the DSP from locking up.
2159          */
2160         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2161                 schedule_timeout_interruptible(1);
2162         if (ixjdebug & 0x0002)
2163                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2164
2165         if (j->cardtype == QTI_PHONECARD)
2166                 ixj_set_port(j, PORT_SPEAKER);
2167         else
2168                 ixj_set_port(j, PORT_POTS);
2169
2170         aec_stop(j);
2171         ixj_play_stop(j);
2172         ixj_record_stop(j);
2173         set_play_volume(j, 0x100);
2174         set_rec_volume(j, 0x100);
2175         ixj_ring_off(j);
2176
2177         /* Restore the tone table to default settings. */
2178         ti.tone_index = 10;
2179         ti.gain0 = 1;
2180         ti.freq0 = hz941;
2181         ti.gain1 = 0;
2182         ti.freq1 = hz1209;
2183         ixj_init_tone(j, &ti);
2184         ti.tone_index = 11;
2185         ti.gain0 = 1;
2186         ti.freq0 = hz941;
2187         ti.gain1 = 0;
2188         ti.freq1 = hz1336;
2189         ixj_init_tone(j, &ti);
2190         ti.tone_index = 12;
2191         ti.gain0 = 1;
2192         ti.freq0 = hz941;
2193         ti.gain1 = 0;
2194         ti.freq1 = hz1477;
2195         ixj_init_tone(j, &ti);
2196         ti.tone_index = 13;
2197         ti.gain0 = 1;
2198         ti.freq0 = hz800;
2199         ti.gain1 = 0;
2200         ti.freq1 = 0;
2201         ixj_init_tone(j, &ti);
2202         ti.tone_index = 14;
2203         ti.gain0 = 1;
2204         ti.freq0 = hz1000;
2205         ti.gain1 = 0;
2206         ti.freq1 = 0;
2207         ixj_init_tone(j, &ti);
2208         ti.tone_index = 15;
2209         ti.gain0 = 1;
2210         ti.freq0 = hz1250;
2211         ti.gain1 = 0;
2212         ti.freq1 = 0;
2213         ixj_init_tone(j, &ti);
2214         ti.tone_index = 16;
2215         ti.gain0 = 1;
2216         ti.freq0 = hz950;
2217         ti.gain1 = 0;
2218         ti.freq1 = 0;
2219         ixj_init_tone(j, &ti);
2220         ti.tone_index = 17;
2221         ti.gain0 = 1;
2222         ti.freq0 = hz1100;
2223         ti.gain1 = 0;
2224         ti.freq1 = 0;
2225         ixj_init_tone(j, &ti);
2226         ti.tone_index = 18;
2227         ti.gain0 = 1;
2228         ti.freq0 = hz1400;
2229         ti.gain1 = 0;
2230         ti.freq1 = 0;
2231         ixj_init_tone(j, &ti);
2232         ti.tone_index = 19;
2233         ti.gain0 = 1;
2234         ti.freq0 = hz1500;
2235         ti.gain1 = 0;
2236         ti.freq1 = 0;
2237         ixj_init_tone(j, &ti);
2238         ti.tone_index = 20;
2239         ti.gain0 = 1;
2240         ti.freq0 = hz1600;
2241         ti.gain1 = 0;
2242         ti.freq1 = 0;
2243         ixj_init_tone(j, &ti);
2244         ti.tone_index = 21;
2245         ti.gain0 = 1;
2246         ti.freq0 = hz1800;
2247         ti.gain1 = 0;
2248         ti.freq1 = 0;
2249         ixj_init_tone(j, &ti);
2250         ti.tone_index = 22;
2251         ti.gain0 = 1;
2252         ti.freq0 = hz2100;
2253         ti.gain1 = 0;
2254         ti.freq1 = 0;
2255         ixj_init_tone(j, &ti);
2256         ti.tone_index = 23;
2257         ti.gain0 = 1;
2258         ti.freq0 = hz1300;
2259         ti.gain1 = 0;
2260         ti.freq1 = 0;
2261         ixj_init_tone(j, &ti);
2262         ti.tone_index = 24;
2263         ti.gain0 = 1;
2264         ti.freq0 = hz2450;
2265         ti.gain1 = 0;
2266         ti.freq1 = 0;
2267         ixj_init_tone(j, &ti);
2268         ti.tone_index = 25;
2269         ti.gain0 = 1;
2270         ti.freq0 = hz350;
2271         ti.gain1 = 0;
2272         ti.freq1 = hz440;
2273         ixj_init_tone(j, &ti);
2274         ti.tone_index = 26;
2275         ti.gain0 = 1;
2276         ti.freq0 = hz440;
2277         ti.gain1 = 0;
2278         ti.freq1 = hz480;
2279         ixj_init_tone(j, &ti);
2280         ti.tone_index = 27;
2281         ti.gain0 = 1;
2282         ti.freq0 = hz480;
2283         ti.gain1 = 0;
2284         ti.freq1 = hz620;
2285         ixj_init_tone(j, &ti);
2286
2287         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2288
2289         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2290
2291         j->ex.bits.dtmf_ready = 0;
2292         j->dtmf_state = 0;
2293         j->dtmf_wp = j->dtmf_rp = 0;
2294         j->rec_mode = j->play_mode = -1;
2295         j->flags.ringing = 0;
2296         j->maxrings = MAXRINGS;
2297         j->ring_cadence = USA_RING_CADENCE;
2298         if(j->cadence_f[5].enable) {
2299                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2300         }
2301         j->drybuffer = 0;
2302         j->winktime = 320;
2303         j->flags.dtmf_oob = 0;
2304         for (cnt = 0; cnt < 4; cnt++)
2305                 j->cadence_f[cnt].enable = 0;
2306
2307         idle(j);
2308
2309         if(j->cardtype == QTI_PHONECARD) {
2310                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2311         }
2312
2313         if (file_p->f_mode & FMODE_READ)
2314                 j->readers--;
2315         if (file_p->f_mode & FMODE_WRITE)
2316                 j->writers--;
2317
2318         if (j->read_buffer && !j->readers) {
2319                 kfree(j->read_buffer);
2320                 j->read_buffer = NULL;
2321                 j->read_buffer_size = 0;
2322         }
2323         if (j->write_buffer && !j->writers) {
2324                 kfree(j->write_buffer);
2325                 j->write_buffer = NULL;
2326                 j->write_buffer_size = 0;
2327         }
2328         j->rec_codec = j->play_codec = 0;
2329         j->rec_frame_size = j->play_frame_size = 0;
2330         j->flags.cidsent = j->flags.cidring = 0;
2331         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2332
2333         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334                 ixj_set_port(j, PORT_PSTN);
2335                 daa_set_mode(j, SOP_PU_SLEEP);
2336                 ixj_set_pots(j, 1);
2337         }
2338         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340         /* Set up the default signals for events */
2341         for (cnt = 0; cnt < 35; cnt++)
2342                 j->ixj_signals[cnt] = SIGIO;
2343
2344         /* Set the excetion signal enable flags */
2345         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346         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 =
2347         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;
2348
2349         file_p->private_data = NULL;
2350         clear_bit(board, &j->busyflags);
2351         return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356         unsigned short fc, cnt, trg;
2357         int var;
2358
2359         trg = 0;
2360         if (ixj_WriteDSPCommand(0x5144, j)) {
2361                 if(ixjdebug & 0x0001) {
2362                         printk(KERN_INFO "Read Frame Counter failed!\n");
2363                 }
2364                 return -1;
2365         }
2366         fc = j->ssr.high << 8 | j->ssr.low;
2367         if (fc == j->frame_count)
2368                 return 1;
2369
2370         j->frame_count = fc;
2371
2372         if (j->dtmf_proc)
2373                 return 1;
2374
2375         var = 10;
2376
2377         for (cnt = 0; cnt < 4; cnt++) {
2378                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379                         if(ixjdebug & 0x0001) {
2380                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381                         }
2382                         return -1;
2383                 }
2384                 if (ixj_WriteDSPCommand(0x515C, j)) {
2385                         if(ixjdebug & 0x0001) {
2386                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387                         }
2388                         return -1;
2389                 }
2390                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392                 if (j->cadence_f[cnt].enable) {
2393                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394                                 if (j->cadence_f[cnt].state == 0) {
2395                                         j->cadence_f[cnt].state = 1;
2396                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399                                 } else if (j->cadence_f[cnt].state == 2 &&
2400                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402                                         if (j->cadence_f[cnt].on2) {
2403                                                 j->cadence_f[cnt].state = 3;
2404                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407                                         } else {
2408                                                 j->cadence_f[cnt].state = 7;
2409                                         }
2410                                 } else if (j->cadence_f[cnt].state == 4 &&
2411                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413                                         if (j->cadence_f[cnt].on3) {
2414                                                 j->cadence_f[cnt].state = 5;
2415                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418                                         } else {
2419                                                 j->cadence_f[cnt].state = 7;
2420                                         }
2421                                 } else {
2422                                         j->cadence_f[cnt].state = 0;
2423                                 }
2424                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425                                 if (j->cadence_f[cnt].state == 1) {
2426                                         if(!j->cadence_f[cnt].on1) {
2427                                                 j->cadence_f[cnt].state = 7;
2428                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430                                                 if(j->cadence_f[cnt].off1) {
2431                                                         j->cadence_f[cnt].state = 2;
2432                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435                                                 } else {
2436                                                         j->cadence_f[cnt].state = 7;
2437                                                 }
2438                                         } else {
2439                                                 j->cadence_f[cnt].state = 0;
2440                                         }
2441                                 } else if (j->cadence_f[cnt].state == 3) {
2442                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444                                                 if(j->cadence_f[cnt].off2) {
2445                                                         j->cadence_f[cnt].state = 4;
2446                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449                                                 } else {
2450                                                         j->cadence_f[cnt].state = 7;
2451                                                 }
2452                                         } else {
2453                                                 j->cadence_f[cnt].state = 0;
2454                                         }
2455                                 } else if (j->cadence_f[cnt].state == 5) {
2456                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458                                                 if(j->cadence_f[cnt].off3) {
2459                                                         j->cadence_f[cnt].state = 6;
2460                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463                                                 } else {
2464                                                         j->cadence_f[cnt].state = 7;
2465                                                 }
2466                                         } else {
2467                                                 j->cadence_f[cnt].state = 0;
2468                                         }
2469                                 } else {
2470                                         j->cadence_f[cnt].state = 0;
2471                                 }
2472                         } else {
2473                                 switch(j->cadence_f[cnt].state) {
2474                                         case 1:
2475                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476                                                    !j->cadence_f[cnt].off1 &&
2477                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479                                                         j->cadence_f[cnt].state = 7;
2480                                                 }
2481                                                 break;
2482                                         case 3:
2483                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484                                                    !j->cadence_f[cnt].off2 &&
2485                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486                                                         j->cadence_f[cnt].state = 7;
2487                                                 }
2488                                                 break;
2489                                         case 5:
2490                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491                                                    !j->cadence_f[cnt].off3) {
2492                                                         j->cadence_f[cnt].state = 7;
2493                                                 }
2494                                                 break;
2495                                 }
2496                         }
2497
2498                         if (ixjdebug & 0x0040) {
2499                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500                                 switch(j->cadence_f[cnt].state) {
2501                                         case 0:
2502                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503                                                 break;
2504                                         case 1:
2505                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507                                                 break;
2508                                         case 2:
2509                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510                                                                                                                         j->cadence_f[cnt].off1max);
2511                                                 break;
2512                                         case 3:
2513                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514                                                                                                                         j->cadence_f[cnt].on2max);
2515                                                 break;
2516                                         case 4:
2517                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518                                                                                                                         j->cadence_f[cnt].off2max);
2519                                                 break;
2520                                         case 5:
2521                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522                                                                                                                         j->cadence_f[cnt].on3max);
2523                                                 break;
2524                                         case 6:
2525                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526                                                                                                                         j->cadence_f[cnt].off3max);
2527                                                 break;
2528                                 }
2529                         }
2530                 }
2531                 if (j->cadence_f[cnt].state == 7) {
2532                         j->cadence_f[cnt].state = 0;
2533                         if (j->cadence_f[cnt].enable == 1)
2534                                 j->cadence_f[cnt].enable = 0;
2535                         switch (cnt) {
2536                         case 0:
2537                                 if(ixjdebug & 0x0020) {
2538                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539                                 }
2540                                 j->ex.bits.fc0 = 1;
2541                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542                                 break;
2543                         case 1:
2544                                 if(ixjdebug & 0x0020) {
2545                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546                                 }
2547                                 j->ex.bits.fc1 = 1;
2548                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549                                 break;
2550                         case 2:
2551                                 if(ixjdebug & 0x0020) {
2552                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553                                 }
2554                                 j->ex.bits.fc2 = 1;
2555                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556                                 break;
2557                         case 3:
2558                                 if(ixjdebug & 0x0020) {
2559                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560                                 }
2561                                 j->ex.bits.fc3 = 1;
2562                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563                                 break;
2564                         }
2565                 }
2566                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569                                 trg = 1;
2570                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571                                 trg = 0;
2572                         }
2573                         switch (cnt) {
2574                         case 0:
2575                                 if(ixjdebug & 0x0020) {
2576                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577                                 }
2578                                 j->ex.bits.f0 = 1;
2579                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580                                 break;
2581                         case 1:
2582                                 if(ixjdebug & 0x0020) {
2583                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584                                 }
2585                                 j->ex.bits.f1 = 1;
2586                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587                                 break;
2588                         case 2:
2589                                 if(ixjdebug & 0x0020) {
2590                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591                                 }
2592                                 j->ex.bits.f2 = 1;
2593                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594                                 break;
2595                         case 3:
2596                                 if(ixjdebug & 0x0020) {
2597                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598                                 }
2599                                 j->ex.bits.f3 = 1;
2600                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601                                 break;
2602                         }
2603                 }
2604         }
2605         return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610         if (j->dtmf_proc) {
2611                 return -1;
2612         }
2613         j->dtmf_proc = 1;
2614
2615         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2616                 return -1;
2617
2618         j->dtmf.bytes.high = j->ssr.high;
2619         j->dtmf.bytes.low = j->ssr.low;
2620         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621                 j->dtmf_state = 1;
2622                 j->dtmf_current = j->dtmf.bits.digit;
2623         }
2624         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2625          {
2626                 if(!j->cidcw_wait) {
2627                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628                         j->dtmf_wp++;
2629                         if (j->dtmf_wp == 79)
2630                                 j->dtmf_wp = 0;
2631                         j->ex.bits.dtmf_ready = 1;
2632                         if(j->ex_sig.bits.dtmf_ready) {
2633                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634                         }
2635                 }
2636                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637                         if(ixjdebug & 0x0020) {
2638                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639                         }
2640                         j->flags.cidcw_ack = 1;
2641                 }
2642                 j->dtmf_state = 0;
2643         }
2644         j->dtmf_proc = 0;
2645
2646         return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657         static unsigned char table_ulaw2alaw[] =
2658         {
2659                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691         };
2692
2693         while (len--)
2694         {
2695                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696                 buff++;
2697         }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702         static unsigned char table_alaw2ulaw[] =
2703         {
2704                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736         };
2737
2738         while (len--)
2739         {
2740                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741                 buff++;
2742         }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747         unsigned long i = *ppos;
2748         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750         DECLARE_WAITQUEUE(wait, current);
2751
2752         if (j->flags.inread)
2753                 return -EALREADY;
2754
2755         j->flags.inread = 1;
2756
2757         add_wait_queue(&j->read_q, &wait);
2758         set_current_state(TASK_INTERRUPTIBLE);
2759         mb();
2760
2761         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762                 ++j->read_wait;
2763                 if (file_p->f_flags & O_NONBLOCK) {
2764                         set_current_state(TASK_RUNNING);
2765                         remove_wait_queue(&j->read_q, &wait);
2766                         j->flags.inread = 0;
2767                         return -EAGAIN;
2768                 }
2769                 if (!ixj_hookstate(j)) {
2770                         set_current_state(TASK_RUNNING);
2771                         remove_wait_queue(&j->read_q, &wait);
2772                         j->flags.inread = 0;
2773                         return 0;
2774                 }
2775                 interruptible_sleep_on(&j->read_q);
2776                 if (signal_pending(current)) {
2777                         set_current_state(TASK_RUNNING);
2778                         remove_wait_queue(&j->read_q, &wait);
2779                         j->flags.inread = 0;
2780                         return -EINTR;
2781                 }
2782         }
2783
2784         remove_wait_queue(&j->read_q, &wait);
2785         set_current_state(TASK_RUNNING);
2786         /* Don't ever copy more than the user asks */
2787         if(j->rec_codec == ALAW)
2788                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790         j->read_buffer_ready = 0;
2791         if (i) {
2792                 j->flags.inread = 0;
2793                 return -EFAULT;
2794         } else {
2795                 j->flags.inread = 0;
2796                 return min(length, j->read_buffer_size);
2797         }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801                           loff_t * ppos)
2802 {
2803         int pre_retval;
2804         ssize_t read_retval = 0;
2805         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807         pre_retval = ixj_PreRead(j, 0L);
2808         switch (pre_retval) {
2809         case NORMAL:
2810                 read_retval = ixj_read(file_p, buf, length, ppos);
2811                 ixj_PostRead(j, 0L);
2812                 break;
2813         case NOPOST:
2814                 read_retval = ixj_read(file_p, buf, length, ppos);
2815                 break;
2816         case POSTONLY:
2817                 ixj_PostRead(j, 0L);
2818                 break;
2819         default:
2820                 read_retval = pre_retval;
2821         }
2822         return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827         unsigned long i = *ppos;
2828         IXJ *j = file_p->private_data;
2829
2830         DECLARE_WAITQUEUE(wait, current);
2831
2832         if (j->flags.inwrite)
2833                 return -EALREADY;
2834
2835         j->flags.inwrite = 1;
2836
2837         add_wait_queue(&j->write_q, &wait);
2838         set_current_state(TASK_INTERRUPTIBLE);
2839         mb();
2840
2841
2842         while (!j->write_buffers_empty) {
2843                 ++j->write_wait;
2844                 if (file_p->f_flags & O_NONBLOCK) {
2845                         set_current_state(TASK_RUNNING);
2846                         remove_wait_queue(&j->write_q, &wait);
2847                         j->flags.inwrite = 0;
2848                         return -EAGAIN;
2849                 }
2850                 if (!ixj_hookstate(j)) {
2851                         set_current_state(TASK_RUNNING);
2852                         remove_wait_queue(&j->write_q, &wait);
2853                         j->flags.inwrite = 0;
2854                         return 0;
2855                 }
2856                 interruptible_sleep_on(&j->write_q);
2857                 if (signal_pending(current)) {
2858                         set_current_state(TASK_RUNNING);
2859                         remove_wait_queue(&j->write_q, &wait);
2860                         j->flags.inwrite = 0;
2861                         return -EINTR;
2862                 }
2863         }
2864         set_current_state(TASK_RUNNING);
2865         remove_wait_queue(&j->write_q, &wait);
2866         if (j->write_buffer_wp + count >= j->write_buffer_end)
2867                 j->write_buffer_wp = j->write_buffer;
2868         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869         if (i) {
2870                 j->flags.inwrite = 0;
2871                 return -EFAULT;
2872         }
2873        if(j->play_codec == ALAW)
2874                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875         j->flags.inwrite = 0;
2876         return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881         int pre_retval;
2882         ssize_t write_retval = 0;
2883
2884         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886         pre_retval = ixj_PreWrite(j, 0L);
2887         switch (pre_retval) {
2888         case NORMAL:
2889                 write_retval = ixj_write(file_p, buf, count, ppos);
2890                 if (write_retval > 0) {
2891                         ixj_PostWrite(j, 0L);
2892                         j->write_buffer_wp += write_retval;
2893                         j->write_buffers_empty--;
2894                 }
2895                 break;
2896         case NOPOST:
2897                 write_retval = ixj_write(file_p, buf, count, ppos);
2898                 if (write_retval > 0) {
2899                         j->write_buffer_wp += write_retval;
2900                         j->write_buffers_empty--;
2901                 }
2902                 break;
2903         case POSTONLY:
2904                 ixj_PostWrite(j, 0L);
2905                 break;
2906         default:
2907                 write_retval = pre_retval;
2908         }
2909         return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914         int cnt, dly;
2915
2916         if (j->read_buffer) {
2917                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918                         if (!(cnt % 16) && !IsRxReady(j)) {
2919                                 dly = 0;
2920                                 while (!IsRxReady(j)) {
2921                                         if (dly++ > 5) {
2922                                                 dly = 0;
2923                                                 break;
2924                                         }
2925                                         udelay(10);
2926                                 }
2927                         }
2928                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930                                 inb_p(j->DSPbase + 0x0E);
2931                                 inb_p(j->DSPbase + 0x0F);
2932                         }
2933                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935                 }
2936                 ++j->framesread;
2937                 if (j->intercom != -1) {
2938                         if (IsTxReady(get_ixj(j->intercom))) {
2939                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940                                         if (!(cnt % 16) && !IsTxReady(j)) {
2941                                                 dly = 0;
2942                                                 while (!IsTxReady(j)) {
2943                                                         if (dly++ > 5) {
2944                                                                 dly = 0;
2945                                                                 break;
2946                                                         }
2947                                                         udelay(10);
2948                                                 }
2949                                         }
2950                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952                                 }
2953                                 get_ixj(j->intercom)->frameswritten++;
2954                         }
2955                 } else {
2956                         j->read_buffer_ready = 1;
2957                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2958
2959                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2960
2961                         if(j->ixj_signals[SIG_READ_READY])
2962                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963                 }
2964         }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969         {
2970                 {
2971                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973                 },
2974                 {
2975                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977                 },
2978                 {
2979                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981                 },
2982                 {
2983                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985                 },
2986                 {
2987                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989                 },
2990                 {
2991                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993                 }
2994         },
2995         {
2996                 {
2997                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999                 },
3000                 {
3001                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003                 },
3004                 {
3005                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007                 },
3008                 {
3009                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011                 },
3012                 {
3013                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015                 },
3016                 {
3017                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019                 }
3020         }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026         while (j->fskcnt < 20) {
3027                 if(j->fskdcnt < (j->fsksize - 1))
3028                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030                 j->fskcnt += 3;
3031         }
3032         j->fskcnt %= 20;
3033
3034         if (!bit)
3035                 j->fskz++;
3036         if (j->fskz >= 6)
3037                 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043         IXJ_CBYTE cb;
3044
3045                 cb.cbyte = byte;
3046                 ixj_write_cid_bit(j, 0);
3047                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055                 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060         int cnt;
3061
3062         for (cnt = 0; cnt < 150; cnt++) {
3063                 ixj_write_cid_bit(j, 0);
3064                 ixj_write_cid_bit(j, 1);
3065         }
3066         for (cnt = 0; cnt < 180; cnt++) {
3067                 ixj_write_cid_bit(j, 1);
3068         }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073         int cnt;
3074
3075         for (cnt = 0; cnt < 80; cnt++) {
3076                 ixj_write_cid_bit(j, 1);
3077         }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082         int cnt;
3083
3084         for (cnt = 0; cnt < strlen(s); cnt++) {
3085                 ixj_write_cid_byte(j, s[cnt]);
3086                 checksum = (checksum + s[cnt]);
3087         }
3088         return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093         int cnt;
3094
3095         for (cnt = 0; cnt < pad; cnt++) {
3096                 if(j->fskdcnt < (j->fsksize - 1))
3097                         j->fskdata[j->fskdcnt++] = 0x0000;
3098         }
3099         for (cnt = 0; cnt < 720; cnt++) {
3100                 if(j->fskdcnt < (j->fsksize - 1))
3101                         j->fskdata[j->fskdcnt++] = 0x0000;
3102         }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107         j->cid_play_codec = j->play_codec;
3108         j->cid_play_frame_size = j->play_frame_size;
3109         j->cid_play_volume = get_play_volume(j);
3110         j->cid_play_flag = j->flags.playing;
3111
3112         j->cid_rec_codec = j->rec_codec;
3113         j->cid_rec_volume = get_rec_volume(j);
3114         j->cid_rec_flag = j->flags.recording;
3115
3116         j->cid_play_aec_level = j->aec_level;
3117
3118         switch(j->baseframe.low) {
3119                 case 0xA0:
3120                         j->cid_base_frame_size = 20;
3121                         break;
3122                 case 0x50:
3123                         j->cid_base_frame_size = 10;
3124                         break;
3125                 case 0xF0:
3126                         j->cid_base_frame_size = 30;
3127                         break;
3128         }
3129
3130         ixj_play_stop(j);
3131         ixj_cpt_stop(j);
3132
3133         j->flags.cidplay = 1;
3134
3135         set_base_frame(j, 30);
3136         set_play_codec(j, LINEAR16);
3137         set_play_volume(j, 0x1B);
3138         ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143         ixj_play_stop(j);
3144
3145         if(j->cidsize > 5000) {
3146                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147         }
3148         j->flags.cidplay = 0;
3149         if(ixjdebug & 0x0200) {
3150                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151         }
3152
3153         ixj_fsk_free(j);
3154
3155         j->fskdcnt = 0;
3156         set_base_frame(j, j->cid_base_frame_size);
3157         set_play_codec(j, j->cid_play_codec);
3158         ixj_aec_start(j, j->cid_play_aec_level);
3159         set_play_volume(j, j->cid_play_volume);
3160
3161         set_rec_codec(j, j->cid_rec_codec);
3162         set_rec_volume(j, j->cid_rec_volume);
3163
3164         if(j->cid_rec_flag)
3165                 ixj_record_start(j);
3166
3167         if(j->cid_play_flag)
3168                 ixj_play_start(j);
3169
3170         if(j->cid_play_flag) {
3171                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3172         }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177         char sdmf1[50];
3178         char sdmf2[50];
3179         char sdmf3[80];
3180         char mdmflen, len1, len2, len3;
3181         int pad;
3182
3183         int checksum = 0;
3184
3185         if (j->dsp.low == 0x20 || j->flags.cidplay)
3186                 return;
3187
3188         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189         j->cidsize = j->cidcnt = 0;
3190
3191         ixj_fsk_alloc(j);
3192
3193         strcpy(sdmf1, j->cid_send.month);
3194         strcat(sdmf1, j->cid_send.day);
3195         strcat(sdmf1, j->cid_send.hour);
3196         strcat(sdmf1, j->cid_send.min);
3197         strcpy(sdmf2, j->cid_send.number);
3198         strcpy(sdmf3, j->cid_send.name);
3199
3200         len1 = strlen(sdmf1);
3201         len2 = strlen(sdmf2);
3202         len3 = strlen(sdmf3);
3203         mdmflen = len1 + len2 + len3 + 6;
3204
3205         while(1){
3206                 ixj_write_cid_seize(j);
3207
3208                 ixj_write_cid_byte(j, 0x80);
3209                 checksum = 0x80;
3210                 ixj_write_cid_byte(j, mdmflen);
3211                 checksum = checksum + mdmflen;
3212
3213                 ixj_write_cid_byte(j, 0x01);
3214                 checksum = checksum + 0x01;
3215                 ixj_write_cid_byte(j, len1);
3216                 checksum = checksum + len1;
3217                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218                 if(ixj_hookstate(j) & 1)
3219                         break;
3220
3221                 ixj_write_cid_byte(j, 0x02);
3222                 checksum = checksum + 0x02;
3223                 ixj_write_cid_byte(j, len2);
3224                 checksum = checksum + len2;
3225                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226                 if(ixj_hookstate(j) & 1)
3227                         break;
3228
3229                 ixj_write_cid_byte(j, 0x07);
3230                 checksum = checksum + 0x07;
3231                 ixj_write_cid_byte(j, len3);
3232                 checksum = checksum + len3;
3233                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234                 if(ixj_hookstate(j) & 1)
3235                         break;
3236
3237                 checksum %= 256;
3238                 checksum ^= 0xFF;
3239                 checksum += 1;
3240
3241                 ixj_write_cid_byte(j, (char) checksum);
3242
3243                 pad = j->fskdcnt % 240;
3244                 if (pad) {
3245                         pad = 240 - pad;
3246                 }
3247                 ixj_pad_fsk(j, pad);
3248                 break;
3249         }
3250
3251         ixj_write_frame(j);
3252 }
3253
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256         IXJ_TONE ti;
3257
3258         char sdmf1[50];
3259         char sdmf2[50];
3260         char sdmf3[80];
3261         char mdmflen, len1, len2, len3;
3262         int pad;
3263
3264         int checksum = 0;
3265
3266         if (j->dsp.low == 0x20 || j->flags.cidplay)
3267                 return;
3268
3269         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270         j->cidsize = j->cidcnt = 0;
3271
3272         ixj_fsk_alloc(j);
3273
3274         j->flags.cidcw_ack = 0;
3275
3276         ti.tone_index = 23;
3277         ti.gain0 = 1;
3278         ti.freq0 = hz440;
3279         ti.gain1 = 0;
3280         ti.freq1 = 0;
3281         ixj_init_tone(j, &ti);
3282
3283         ixj_set_tone_on(1500, j);
3284         ixj_set_tone_off(32, j);
3285         if(ixjdebug & 0x0200) {
3286                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287         }
3288         ixj_play_tone(j, 23);
3289
3290         clear_bit(j->board, &j->busyflags);
3291         while(j->tone_state)
3292                 schedule_timeout_interruptible(1);
3293         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294                 schedule_timeout_interruptible(1);
3295         if(ixjdebug & 0x0200) {
3296                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297         }
3298
3299         ti.tone_index = 24;
3300         ti.gain0 = 1;
3301         ti.freq0 = hz2130;
3302         ti.gain1 = 0;
3303         ti.freq1 = hz2750;
3304         ixj_init_tone(j, &ti);
3305
3306         ixj_set_tone_off(10, j);
3307         ixj_set_tone_on(600, j);
3308         if(ixjdebug & 0x0200) {
3309                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310         }
3311         ixj_play_tone(j, 24);
3312
3313         clear_bit(j->board, &j->busyflags);
3314         while(j->tone_state)
3315                 schedule_timeout_interruptible(1);
3316         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317                 schedule_timeout_interruptible(1);
3318         if(ixjdebug & 0x0200) {
3319                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320         }
3321
3322         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324         clear_bit(j->board, &j->busyflags);
3325         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326                 schedule_timeout_interruptible(1);
3327         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328                 schedule_timeout_interruptible(1);
3329         j->cidcw_wait = 0;
3330         if(!j->flags.cidcw_ack) {
3331                 if(ixjdebug & 0x0200) {
3332                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333                 }
3334                 ixj_post_cid(j);
3335                 if(j->cid_play_flag) {
3336                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3337                 }
3338                 return;
3339         } else {
3340                 ixj_pre_cid(j);
3341         }
3342         j->flags.cidcw_ack = 0;
3343         strcpy(sdmf1, j->cid_send.month);
3344         strcat(sdmf1, j->cid_send.day);
3345         strcat(sdmf1, j->cid_send.hour);
3346         strcat(sdmf1, j->cid_send.min);
3347         strcpy(sdmf2, j->cid_send.number);
3348         strcpy(sdmf3, j->cid_send.name);
3349
3350         len1 = strlen(sdmf1);
3351         len2 = strlen(sdmf2);
3352         len3 = strlen(sdmf3);
3353         mdmflen = len1 + len2 + len3 + 6;
3354
3355         ixj_write_cidcw_seize(j);
3356
3357         ixj_write_cid_byte(j, 0x80);
3358         checksum = 0x80;
3359         ixj_write_cid_byte(j, mdmflen);
3360         checksum = checksum + mdmflen;
3361
3362         ixj_write_cid_byte(j, 0x01);
3363         checksum = checksum + 0x01;
3364         ixj_write_cid_byte(j, len1);
3365         checksum = checksum + len1;
3366         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368         ixj_write_cid_byte(j, 0x02);
3369         checksum = checksum + 0x02;
3370         ixj_write_cid_byte(j, len2);
3371         checksum = checksum + len2;
3372         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374         ixj_write_cid_byte(j, 0x07);
3375         checksum = checksum + 0x07;
3376         ixj_write_cid_byte(j, len3);
3377         checksum = checksum + len3;
3378         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380         checksum %= 256;
3381         checksum ^= 0xFF;
3382         checksum += 1;
3383
3384         ixj_write_cid_byte(j, (char) checksum);
3385
3386         pad = j->fskdcnt % 240;
3387         if (pad) {
3388                 pad = 240 - pad;
3389         }
3390         ixj_pad_fsk(j, pad);
3391         if(ixjdebug & 0x0200) {
3392                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393         }
3394 }
3395
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398         char mdmflen;
3399         int pad;
3400
3401         int checksum = 0;
3402
3403         if (j->dsp.low == 0x20 || j->flags.cidplay)
3404                 return;
3405
3406         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407         j->cidsize = j->cidcnt = 0;
3408
3409         ixj_fsk_alloc(j);
3410
3411         mdmflen = 3;
3412
3413         if (j->port == PORT_POTS)
3414                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416         ixj_write_cid_seize(j);
3417
3418         ixj_write_cid_byte(j, 0x82);
3419         checksum = 0x82;
3420         ixj_write_cid_byte(j, mdmflen);
3421         checksum = checksum + mdmflen;
3422
3423         ixj_write_cid_byte(j, 0x0B);
3424         checksum = checksum + 0x0B;
3425         ixj_write_cid_byte(j, 1);
3426         checksum = checksum + 1;
3427
3428         if(msg) {
3429                 ixj_write_cid_byte(j, 0xFF);
3430                 checksum = checksum + 0xFF;
3431         }
3432         else {
3433                 ixj_write_cid_byte(j, 0x00);
3434                 checksum = checksum + 0x00;
3435         }
3436
3437         checksum %= 256;
3438         checksum ^= 0xFF;
3439         checksum += 1;
3440
3441         ixj_write_cid_byte(j, (char) checksum);
3442
3443         pad = j->fskdcnt % 240;
3444         if (pad) {
3445                 pad = 240 - pad;
3446         }
3447         ixj_pad_fsk(j, pad);
3448 }
3449
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452         int cnt, frame_count, dly;
3453         IXJ_WORD dat;
3454
3455         frame_count = 0;
3456         if(j->flags.cidplay) {
3457                 for(cnt = 0; cnt < 480; cnt++) {
3458                         if (!(cnt % 16) && !IsTxReady(j)) {
3459                                 dly = 0;
3460                                 while (!IsTxReady(j)) {
3461                                         if (dly++ > 5) {
3462                                                 dly = 0;
3463                                                 break;
3464                                         }
3465                                         udelay(10);
3466                                 }
3467                         }
3468                         dat.word = j->fskdata[j->cidcnt++];
3469                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471                         cnt++;
3472                 }
3473                 if(j->cidcnt >= j->fskdcnt) {
3474                         ixj_post_cid(j);
3475                 }
3476                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477                    and there is real audio data in the buffer, we need to throw it away because
3478                    we just used it's time slot */
3479                 if (j->write_buffer_rp > j->write_buffer_wp) {
3480                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3481                         if (j->write_buffer_rp >= j->write_buffer_end) {
3482                                 j->write_buffer_rp = j->write_buffer;
3483                         }
3484                         j->write_buffers_empty++;
3485                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3486
3487                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3488                 }
3489         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490                 if (j->write_buffer_wp > j->write_buffer_rp) {
3491                         frame_count =
3492                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493                 }
3494                 if (j->write_buffer_rp > j->write_buffer_wp) {
3495                         frame_count =
3496                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498                 }
3499                 if (frame_count >= 1) {
3500                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501                                 BYTES blankword;
3502
3503                                 switch (j->play_mode) {
3504                                 case PLAYBACK_MODE_ULAW:
3505                                 case PLAYBACK_MODE_ALAW:
3506                                         blankword.low = blankword.high = 0xFF;
3507                                         break;
3508                                 case PLAYBACK_MODE_8LINEAR:
3509                                 case PLAYBACK_MODE_16LINEAR:
3510                                 default:
3511                                         blankword.low = blankword.high = 0x00;
3512                                         break;
3513                                 case PLAYBACK_MODE_8LINEAR_WSS:
3514                                         blankword.low = blankword.high = 0x80;
3515                                         break;
3516                                 }
3517                                 for (cnt = 0; cnt < 16; cnt++) {
3518                                         if (!(cnt % 16) && !IsTxReady(j)) {
3519                                                 dly = 0;
3520                                                 while (!IsTxReady(j)) {
3521                                                         if (dly++ > 5) {
3522                                                                 dly = 0;
3523                                                                 break;
3524                                                         }
3525                                                         udelay(10);
3526                                                 }
3527                                         }
3528                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3529                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3530                                 }
3531                                 j->flags.play_first_frame = 0;
3532                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533                                 for (cnt = 0; cnt < 24; cnt++) {
3534                                         BYTES blankword;
3535
3536                                         if(cnt == 12) {
3537                                                 blankword.low = 0x02;
3538                                                 blankword.high = 0x00;
3539                                         }
3540                                         else {
3541                                                 blankword.low = blankword.high = 0x00;
3542                                         }
3543                                         if (!(cnt % 16) && !IsTxReady(j)) {
3544                                                 dly = 0;
3545                                                 while (!IsTxReady(j)) {
3546                                                         if (dly++ > 5) {
3547                                                                 dly = 0;
3548                                                                 break;
3549                                                         }
3550                                                         udelay(10);
3551                                                 }
3552                                         }
3553                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3554                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3555                                 }
3556                                 j->flags.play_first_frame = 0;
3557                         }
3558                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559                                 if (!(cnt % 16) && !IsTxReady(j)) {
3560                                         dly = 0;
3561                                         while (!IsTxReady(j)) {
3562                                                 if (dly++ > 5) {
3563                                                         dly = 0;
3564                                                         break;
3565                                                 }
3566                                                 udelay(10);
3567                                         }
3568                                 }
3569                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3570                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571                                         if (j->write_buffer_rp[cnt] == 0 &&
3572                                             j->write_buffer_rp[cnt + 1] == 0 &&
3573                                             j->write_buffer_rp[cnt + 2] == 0 &&
3574                                             j->write_buffer_rp[cnt + 3] == 0 &&
3575                                             j->write_buffer_rp[cnt + 4] == 0 &&
3576                                             j->write_buffer_rp[cnt + 5] == 0 &&
3577                                             j->write_buffer_rp[cnt + 6] == 0 &&
3578                                             j->write_buffer_rp[cnt + 7] == 0 &&
3579                                             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_path.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         default:
4874                 bytes.high = 0xF0 + cr;
4875                 break;
4876         }
4877
4878         bytes.low = 0x00;
4879
4880         outb_p(bytes.high, j->XILINXbase + 0x03);
4881         outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883         if (!SCI_Control(j, SCI_Enable_DAA))
4884                 return 0;
4885
4886         bytes.high = inb_p(j->XILINXbase + 0x03);
4887         bytes.low = inb_p(j->XILINXbase + 0x02);
4888         if (bytes.low != ALISDAA_ID_BYTE) {
4889                 if (ixjdebug & 0x0001)
4890                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891                 return 0;
4892         }
4893         if (!SCI_Control(j, SCI_Enable_DAA))
4894                 return 0;
4895         if (!SCI_Control(j, SCI_End))
4896                 return 0;
4897
4898         wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900         switch(cr){
4901                 case 5:
4902                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903                         break;
4904                 case 4:
4905                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906                         break;
4907                 case 3:
4908                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909                         break;
4910                 case 2:
4911                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912                         break;
4913                 case 1:
4914                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915                         break;
4916                 case 0:
4917                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918                         break;
4919                 default:
4920                         return 0;
4921         }
4922         return 1;
4923 }
4924
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927         int i;
4928         BYTES bytes;
4929
4930         if (ixjdebug & 0x0002)
4931                 printk("DAA Clearing CID ram\n");
4932
4933         if (!SCI_Prepare(j))
4934                 return 0;
4935
4936         bytes.high = 0x58;
4937         bytes.low = 0x00;
4938         outb_p(bytes.high, j->XILINXbase + 0x03);
4939         outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941         if (!SCI_Control(j, SCI_Enable_DAA))
4942                 return 0;
4943
4944         if (!SCI_WaitHighSCI(j))
4945                 return 0;
4946
4947         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948                 bytes.high = bytes.low = 0x00;
4949                 outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951                 if (i < ALISDAA_CALLERID_SIZE - 1)
4952                         outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954                 if (!SCI_Control(j, SCI_Enable_DAA))
4955                         return 0;
4956
4957                 if (!SCI_WaitHighSCI(j))
4958                         return 0;
4959
4960         }
4961
4962         if (!SCI_Control(j, SCI_End))
4963                 return 0;
4964
4965         if (ixjdebug & 0x0002)
4966                 printk("DAA CID ram cleared\n");
4967
4968         return 1;
4969 }
4970
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973         int i;
4974         BYTES bytes;
4975         char CID[ALISDAA_CALLERID_SIZE];
4976         bool mContinue;
4977         char *pIn, *pOut;
4978
4979         if (!SCI_Prepare(j))
4980                 return 0;
4981
4982         bytes.high = 0x78;
4983         bytes.low = 0x00;
4984         outb_p(bytes.high, j->XILINXbase + 0x03);
4985         outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987         if (!SCI_Control(j, SCI_Enable_DAA))
4988                 return 0;
4989
4990         if (!SCI_WaitHighSCI(j))
4991                 return 0;
4992
4993         bytes.high = inb_p(j->XILINXbase + 0x03);
4994         bytes.low = inb_p(j->XILINXbase + 0x02);
4995         if (bytes.low != ALISDAA_ID_BYTE) {
4996                 if (ixjdebug & 0x0001)
4997                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998                 return 0;
4999         }
5000         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001                 bytes.high = bytes.low = 0x00;
5002                 outb_p(bytes.high, j->XILINXbase + 0x03);
5003                 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005                 if (!SCI_Control(j, SCI_Enable_DAA))
5006                         return 0;
5007
5008                 if (!SCI_WaitHighSCI(j))
5009                         return 0;
5010
5011                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013         }
5014
5015         if (!SCI_Control(j, SCI_End))
5016                 return 0;
5017
5018         pIn = CID;
5019         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020         mContinue = true;
5021         while (mContinue) {
5022                 if ((pIn[1] & 0x03) == 0x01) {
5023                         pOut[0] = pIn[0];
5024                 }
5025                 if ((pIn[2] & 0x0c) == 0x04) {
5026                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027                 }
5028                 if ((pIn[3] & 0x30) == 0x10) {
5029                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030                 }
5031                 if ((pIn[4] & 0xc0) == 0x40) {
5032                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033                 } else {
5034                         mContinue = false;
5035                 }
5036                 pIn += 5, pOut += 4;
5037         }
5038         memset(&j->cid, 0, sizeof(PHONE_CID));
5039         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040         pOut += 4;
5041         strncpy(j->cid.month, pOut, 2);
5042         pOut += 2;
5043         strncpy(j->cid.day, pOut, 2);
5044         pOut += 2;
5045         strncpy(j->cid.hour, pOut, 2);
5046         pOut += 2;
5047         strncpy(j->cid.min, pOut, 2);
5048         pOut += 3;
5049         j->cid.numlen = *pOut;
5050         pOut += 1;
5051         strncpy(j->cid.number, pOut, j->cid.numlen);
5052         pOut += j->cid.numlen + 1;
5053         j->cid.namelen = *pOut;
5054         pOut += 1;
5055         strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057         ixj_daa_cid_reset(j);
5058         return 1;
5059 }
5060
5061 static char daa_get_version(IXJ *j)
5062 {
5063         BYTES bytes;
5064
5065         if (!SCI_Prepare(j))
5066                 return 0;
5067
5068         bytes.high = 0x35;
5069         bytes.low = 0x00;
5070         outb_p(bytes.high, j->XILINXbase + 0x03);
5071         outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073         if (!SCI_Control(j, SCI_Enable_DAA))
5074                 return 0;
5075
5076         bytes.high = inb_p(j->XILINXbase + 0x03);
5077         bytes.low = inb_p(j->XILINXbase + 0x02);
5078         if (bytes.low != ALISDAA_ID_BYTE) {
5079                 if (ixjdebug & 0x0001)
5080                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081                 return 0;
5082         }
5083         if (!SCI_Control(j, SCI_Enable_DAA))
5084                 return 0;
5085
5086         if (!SCI_Control(j, SCI_End))
5087                 return 0;
5088
5089         bytes.high = inb_p(j->XILINXbase + 0x03);
5090         bytes.low = inb_p(j->XILINXbase + 0x02);
5091         if (ixjdebug & 0x0002)
5092                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094         return bytes.high;
5095 }
5096
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099         /* NOTE:
5100               The DAA *MUST* be in the conversation mode if the
5101               PSTN line is to be seized (PSTN line off-hook).
5102               Taking the PSTN line off-hook while the DAA is in
5103               a mode other than conversation mode will cause a
5104               hardware failure of the ALIS-A part.
5105
5106            NOTE:
5107               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108               if the PSTN line is on-hook.  Failure to have the PSTN line
5109               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110               ALIS-A part.
5111         */
5112
5113         BYTES bytes;
5114
5115         j->flags.pstn_rmr = 0;
5116
5117         if (!SCI_Prepare(j))
5118                 return 0;
5119
5120         switch (mode) {
5121         case SOP_PU_RESET:
5122                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5123
5124                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5125                 j->pld_slicw.bits.rly2 = 0;
5126                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127                 bytes.high = 0x10;
5128                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129                 daa_load(&bytes, j);
5130                 if (!SCI_Prepare(j))
5131                         return 0;
5132
5133                 j->daa_mode = SOP_PU_SLEEP;
5134                 break;
5135         case SOP_PU_SLEEP:
5136                 if(j->daa_mode == SOP_PU_SLEEP)
5137                 {
5138                         break;
5139                 }
5140                 if (ixjdebug & 0x0008)
5141                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5143                 {
5144                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5145
5146                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5147                         j->pld_slicw.bits.rly2 = 0;
5148                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149                         bytes.high = 0x10;
5150                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151                         daa_load(&bytes, j);
5152                         if (!SCI_Prepare(j))
5153                                 return 0;
5154                 }
5155                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5156
5157                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5158                 j->pld_slicw.bits.rly2 = 0;
5159                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160                 bytes.high = 0x10;
5161                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162                 daa_load(&bytes, j);
5163                 if (!SCI_Prepare(j))
5164                         return 0;
5165
5166                 j->daa_mode = SOP_PU_SLEEP;
5167                 j->flags.pstn_ringing = 0;
5168                 j->ex.bits.pstn_ring = 0;
5169                 j->pstn_sleeptil = jiffies + (hertz / 4);
5170                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5171                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5172                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5173                 break;
5174         case SOP_PU_RINGING:
5175                 if (ixjdebug & 0x0008)
5176                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5178
5179                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5180                 j->pld_slicw.bits.rly2 = 0;
5181                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182                 bytes.high = 0x50;
5183                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184                 daa_load(&bytes, j);
5185                 if (!SCI_Prepare(j))
5186                         return 0;
5187                 j->daa_mode = SOP_PU_RINGING;
5188                 break;
5189         case SOP_PU_CONVERSATION:
5190                 if (ixjdebug & 0x0008)
5191                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192                 bytes.high = 0x90;
5193                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194                 daa_load(&bytes, j);
5195                 if (!SCI_Prepare(j))
5196                         return 0;
5197                 j->pld_slicw.bits.rly2 = 1;
5198                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5200
5201                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202                 j->daa_mode = SOP_PU_CONVERSATION;
5203                 j->flags.pstn_ringing = 0;
5204                 j->ex.bits.pstn_ring = 0;
5205                 j->pstn_sleeptil = jiffies;
5206                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207                 break;
5208         case SOP_PU_PULSEDIALING:
5209                 if (ixjdebug & 0x0008)
5210                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5212
5213                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5214                 j->pld_slicw.bits.rly2 = 0;
5215                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216                 bytes.high = 0xD0;
5217                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218                 daa_load(&bytes, j);
5219                 if (!SCI_Prepare(j))
5220                         return 0;
5221                 j->daa_mode = SOP_PU_PULSEDIALING;
5222                 break;
5223         default:
5224                 break;
5225         }
5226         return 1;
5227 }
5228
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231         BYTES bytes;
5232
5233         j->flags.pstncheck = 1;
5234
5235         daa_set_mode(j, SOP_PU_SLEEP);
5236
5237         if (!SCI_Prepare(j))
5238                 return 0;
5239
5240         outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242         bytes.high = 0x14;
5243         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244         if (!daa_load(&bytes, j))
5245                 return 0;
5246
5247         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249         if (!daa_load(&bytes, j))
5250                 return 0;
5251
5252         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254         if (!daa_load(&bytes, j))
5255                 return 0;
5256
5257         if (!SCI_Prepare(j))
5258                 return 0;
5259
5260         bytes.high = 0x1F;
5261         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262         if (!daa_load(&bytes, j))
5263                 return 0;
5264
5265         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267         if (!daa_load(&bytes, j))
5268                 return 0;
5269
5270         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272         if (!daa_load(&bytes, j))
5273                 return 0;
5274
5275         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277         if (!daa_load(&bytes, j))
5278                 return 0;
5279
5280         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281         bytes.low = 0x00;
5282         if (!daa_load(&bytes, j))
5283                 return 0;
5284
5285         if (!SCI_Prepare(j))
5286                 return 0;
5287
5288         bytes.high = 0x00;
5289         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290         if (!daa_load(&bytes, j))
5291                 return 0;
5292
5293         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295         if (!daa_load(&bytes, j))
5296                 return 0;
5297
5298         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300         if (!daa_load(&bytes, j))
5301                 return 0;
5302
5303         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305         if (!daa_load(&bytes, j))
5306                 return 0;
5307
5308         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309         bytes.low = 0x00;
5310         if (!daa_load(&bytes, j))
5311                 return 0;
5312
5313         if (!SCI_Control(j, SCI_End))
5314                 return 0;
5315         if (!SCI_WaitLowSCI(j))
5316                 return 0;
5317
5318         bytes.high = 0x01;
5319         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320         if (!daa_load(&bytes, j))
5321                 return 0;
5322
5323         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325         if (!daa_load(&bytes, j))
5326                 return 0;
5327
5328         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330         if (!daa_load(&bytes, j))
5331                 return 0;
5332
5333         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335         if (!daa_load(&bytes, j))
5336                 return 0;
5337
5338         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339         bytes.low = 0x00;
5340         if (!daa_load(&bytes, j))
5341                 return 0;
5342
5343         if (!SCI_Control(j, SCI_End))
5344                 return 0;
5345         if (!SCI_WaitLowSCI(j))
5346                 return 0;
5347
5348         bytes.high = 0x02;
5349         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350         if (!daa_load(&bytes, j))
5351                 return 0;
5352
5353         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355         if (!daa_load(&bytes, j))
5356                 return 0;
5357
5358         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360         if (!daa_load(&bytes, j))
5361                 return 0;
5362
5363         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365         if (!daa_load(&bytes, j))
5366                 return 0;
5367
5368         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369         bytes.low = 0x00;
5370         if (!daa_load(&bytes, j))
5371                 return 0;
5372
5373         if (!SCI_Control(j, SCI_End))
5374                 return 0;
5375         if (!SCI_WaitLowSCI(j))
5376                 return 0;
5377
5378         bytes.high = 0x03;
5379         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380         if (!daa_load(&bytes, j))
5381                 return 0;
5382
5383         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385         if (!daa_load(&bytes, j))
5386                 return 0;
5387
5388         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390         if (!daa_load(&bytes, j))
5391                 return 0;
5392
5393         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395         if (!daa_load(&bytes, j))
5396                 return 0;
5397
5398         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399         bytes.low = 0x00;
5400         if (!daa_load(&bytes, j))
5401                 return 0;
5402
5403         if (!SCI_Control(j, SCI_End))
5404                 return 0;
5405         if (!SCI_WaitLowSCI(j))
5406                 return 0;
5407
5408         bytes.high = 0x04;
5409         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410         if (!daa_load(&bytes, j))
5411                 return 0;
5412
5413         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415         if (!daa_load(&bytes, j))
5416                 return 0;
5417
5418         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420         if (!daa_load(&bytes, j))
5421                 return 0;
5422
5423         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425         if (!daa_load(&bytes, j))
5426                 return 0;
5427
5428         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429         bytes.low = 0x00;
5430         if (!daa_load(&bytes, j))
5431                 return 0;
5432
5433         if (!SCI_Control(j, SCI_End))
5434                 return 0;
5435         if (!SCI_WaitLowSCI(j))
5436                 return 0;
5437
5438         bytes.high = 0x05;
5439         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440         if (!daa_load(&bytes, j))
5441                 return 0;
5442
5443         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445         if (!daa_load(&bytes, j))
5446                 return 0;
5447
5448         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450         if (!daa_load(&bytes, j))
5451                 return 0;
5452
5453         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455         if (!daa_load(&bytes, j))
5456                 return 0;
5457
5458         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459         bytes.low = 0x00;
5460         if (!daa_load(&bytes, j))
5461                 return 0;
5462
5463         if (!SCI_Control(j, SCI_End))
5464                 return 0;
5465         if (!SCI_WaitLowSCI(j))
5466                 return 0;
5467
5468         bytes.high = 0x06;
5469         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470         if (!daa_load(&bytes, j))
5471                 return 0;
5472
5473         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475         if (!daa_load(&bytes, j))
5476                 return 0;
5477
5478         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480         if (!daa_load(&bytes, j))
5481                 return 0;
5482
5483         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485         if (!daa_load(&bytes, j))
5486                 return 0;
5487
5488         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489         bytes.low = 0x00;
5490         if (!daa_load(&bytes, j))
5491                 return 0;
5492
5493         if (!SCI_Control(j, SCI_End))
5494                 return 0;
5495         if (!SCI_WaitLowSCI(j))
5496                 return 0;
5497
5498         bytes.high = 0x07;
5499         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500         if (!daa_load(&bytes, j))
5501                 return 0;
5502
5503         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505         if (!daa_load(&bytes, j))
5506                 return 0;
5507
5508         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510         if (!daa_load(&bytes, j))
5511                 return 0;
5512
5513         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515         if (!daa_load(&bytes, j))
5516                 return 0;
5517
5518         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519         bytes.low = 0x00;
5520         if (!daa_load(&bytes, j))
5521                 return 0;
5522
5523         if (!SCI_Control(j, SCI_End))
5524                 return 0;
5525         if (!SCI_WaitLowSCI(j))
5526                 return 0;
5527
5528         bytes.high = 0x08;
5529         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530         if (!daa_load(&bytes, j))
5531                 return 0;
5532
5533         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535         if (!daa_load(&bytes, j))
5536                 return 0;
5537
5538         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540         if (!daa_load(&bytes, j))
5541                 return 0;
5542
5543         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545         if (!daa_load(&bytes, j))
5546                 return 0;
5547
5548         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549         bytes.low = 0x00;
5550         if (!daa_load(&bytes, j))
5551                 return 0;
5552
5553         if (!SCI_Control(j, SCI_End))
5554                 return 0;
5555         if (!SCI_WaitLowSCI(j))
5556                 return 0;
5557
5558         bytes.high = 0x09;
5559         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560         if (!daa_load(&bytes, j))
5561                 return 0;
5562
5563         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565         if (!daa_load(&bytes, j))
5566                 return 0;
5567
5568         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569         bytes.low = 0x00;
5570         if (!daa_load(&bytes, j))
5571                 return 0;
5572
5573         if (!SCI_Control(j, SCI_End))
5574                 return 0;
5575         if (!SCI_WaitLowSCI(j))
5576                 return 0;
5577
5578         bytes.high = 0x0A;
5579         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580         if (!daa_load(&bytes, j))
5581                 return 0;
5582
5583         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585         if (!daa_load(&bytes, j))
5586                 return 0;
5587
5588         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589         bytes.low = 0x00;
5590         if (!daa_load(&bytes, j))
5591                 return 0;
5592
5593         if (!SCI_Control(j, SCI_End))
5594                 return 0;
5595         if (!SCI_WaitLowSCI(j))
5596                 return 0;
5597
5598         bytes.high = 0x0B;
5599         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600         if (!daa_load(&bytes, j))
5601                 return 0;
5602
5603         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605         if (!daa_load(&bytes, j))
5606                 return 0;
5607
5608         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609         bytes.low = 0x00;
5610         if (!daa_load(&bytes, j))
5611                 return 0;
5612
5613         if (!SCI_Control(j, SCI_End))
5614                 return 0;
5615         if (!SCI_WaitLowSCI(j))
5616                 return 0;
5617
5618         bytes.high = 0x0C;
5619         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620         if (!daa_load(&bytes, j))
5621                 return 0;
5622
5623         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625         if (!daa_load(&bytes, j))
5626                 return 0;
5627
5628         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629         bytes.low = 0x00;
5630         if (!daa_load(&bytes, j))
5631                 return 0;
5632
5633         if (!SCI_Control(j, SCI_End))
5634                 return 0;
5635         if (!SCI_WaitLowSCI(j))
5636                 return 0;
5637
5638         bytes.high = 0x0D;
5639         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640         if (!daa_load(&bytes, j))
5641                 return 0;
5642
5643         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645         if (!daa_load(&bytes, j))
5646                 return 0;
5647
5648         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649         bytes.low = 0x00;
5650         if (!daa_load(&bytes, j))
5651                 return 0;
5652
5653         if (!SCI_Control(j, SCI_End))
5654                 return 0;
5655         if (!SCI_WaitLowSCI(j))
5656                 return 0;
5657
5658         bytes.high = 0x0E;
5659         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660         if (!daa_load(&bytes, j))
5661                 return 0;
5662
5663         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665         if (!daa_load(&bytes, j))
5666                 return 0;
5667
5668         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670         if (!daa_load(&bytes, j))
5671                 return 0;
5672
5673         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675         if (!daa_load(&bytes, j))
5676                 return 0;
5677
5678         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679         bytes.low = 0x00;
5680         if (!daa_load(&bytes, j))
5681                 return 0;
5682
5683         if (!SCI_Control(j, SCI_End))
5684                 return 0;
5685         if (!SCI_WaitLowSCI(j))
5686                 return 0;
5687
5688         bytes.high = 0x0F;
5689         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690         if (!daa_load(&bytes, j))
5691                 return 0;
5692
5693         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695         if (!daa_load(&bytes, j))
5696                 return 0;
5697
5698         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700         if (!daa_load(&bytes, j))
5701                 return 0;
5702
5703         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705         if (!daa_load(&bytes, j))
5706                 return 0;
5707
5708         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709         bytes.low = 0x00;
5710         if (!daa_load(&bytes, j))
5711                 return 0;
5712
5713         udelay(32);
5714         j->pld_scrr.byte = inb_p(j->XILINXbase);
5715         if (!SCI_Control(j, SCI_End))
5716                 return 0;
5717
5718         outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720         if (ixjdebug & 0x0002)
5721                 printk("DAA Coefficients Loaded\n");
5722
5723         j->flags.pstncheck = 0;
5724         return 1;
5725 }
5726
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729         j->tone_off_time = arg;
5730         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5731
5732                 return -1;
5733         if (ixj_WriteDSPCommand(arg, j))
5734                 return -1;
5735         return 0;
5736 }
5737
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5741
5742                 return -1;
5743         return 0;
5744 }
5745
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5749
5750                 return -1;
5751         return 0;
5752 }
5753
5754 static void ixj_busytone(IXJ *j)
5755 {
5756         j->flags.ringback = 0;
5757         j->flags.dialtone = 0;
5758         j->flags.busytone = 1;
5759         ixj_set_tone_on(0x07D0, j);
5760         ixj_set_tone_off(0x07D0, j);
5761         ixj_play_tone(j, 27);
5762 }
5763
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766         j->flags.ringback = 0;
5767         j->flags.dialtone = 1;
5768         j->flags.busytone = 0;
5769         if (j->dsp.low == 0x20) {
5770                 return;
5771         } else {
5772                 ixj_set_tone_on(0xFFFF, j);
5773                 ixj_set_tone_off(0x0000, j);
5774                 ixj_play_tone(j, 25);
5775         }
5776 }
5777
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780         if(j->tone_state || j->tone_cadence_state)
5781         {
5782                 j->flags.dialtone = 0;
5783                 j->flags.busytone = 0;
5784                 j->flags.ringback = 0;
5785                 ixj_set_tone_on(0x0001, j);
5786                 ixj_set_tone_off(0x0000, j);
5787                 ixj_play_tone(j, 0);
5788                 j->tone_state = j->tone_cadence_state = 0;
5789                 if (j->cadence_t) {
5790                         kfree(j->cadence_t->ce);
5791                         kfree(j->cadence_t);
5792                         j->cadence_t = NULL;
5793                 }
5794         }
5795         if (j->play_mode == -1 && j->rec_mode == -1)
5796                 idle(j);
5797         if (j->play_mode != -1 && j->dsp.low == 0x20)
5798                 ixj_play_start(j);
5799         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800                 ixj_record_start(j);
5801 }
5802
5803 static void ixj_ringback(IXJ *j)
5804 {
5805         j->flags.busytone = 0;
5806         j->flags.dialtone = 0;
5807         j->flags.ringback = 1;
5808         ixj_set_tone_on(0x0FA0, j);
5809         ixj_set_tone_off(0x2EE0, j);
5810         ixj_play_tone(j, 26);
5811 }
5812
5813 static void ixj_testram(IXJ *j)
5814 {
5815         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820         ixj_cadence *lcp;
5821         IXJ_CADENCE_ELEMENT __user *cep;
5822         IXJ_CADENCE_ELEMENT *lcep;
5823         IXJ_TONE ti;
5824         int err;
5825
5826         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827         if (lcp == NULL)
5828                 return -ENOMEM;
5829
5830         err = -EFAULT;
5831         if (copy_from_user(&lcp->elements_used,
5832                            &cp->elements_used, sizeof(int)))
5833                 goto out;
5834         if (copy_from_user(&lcp->termination,
5835                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836                 goto out;
5837         if (get_user(cep, &cp->ce))
5838                 goto out;
5839
5840         err = -EINVAL;
5841         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842                 goto out;
5843
5844         err = -ENOMEM;
5845         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846         if (!lcep)
5847                 goto out;
5848
5849         err = -EFAULT;
5850         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851                 goto out1;
5852
5853         if (j->cadence_t) {
5854                 kfree(j->cadence_t->ce);
5855                 kfree(j->cadence_t);
5856         }
5857         lcp->ce = (void *) lcep;
5858         j->cadence_t = lcp;
5859         j->tone_cadence_state = 0;
5860         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868                 ixj_init_tone(j, &ti);
5869         }
5870         ixj_play_tone(j, lcp->ce[0].index);
5871         return 1;
5872 out1:
5873         kfree(lcep);
5874 out:
5875         kfree(lcp);
5876         return err;
5877 }
5878
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881         IXJ_FILTER_CADENCE *lcp;
5882         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5883         if (lcp == NULL) {
5884                 if(ixjdebug & 0x0001) {
5885                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5886                 }
5887                 return -ENOMEM;
5888         }
5889         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5890                 if(ixjdebug & 0x0001) {
5891                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5892                 }
5893                 kfree(lcp);
5894                 return -EFAULT;
5895         }
5896         if (lcp->filter > 5) {
5897                 if(ixjdebug & 0x0001) {
5898                         printk(KERN_INFO "Cadence out of range\n");
5899                 }
5900                 kfree(lcp);
5901                 return -1;
5902         }
5903         j->cadence_f[lcp->filter].state = 0;
5904         j->cadence_f[lcp->filter].enable = lcp->enable;
5905         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5906         j->cadence_f[lcp->filter].on1 = lcp->on1;
5907         j->cadence_f[lcp->filter].on1min = 0;
5908         j->cadence_f[lcp->filter].on1max = 0;
5909         j->cadence_f[lcp->filter].off1 = lcp->off1;
5910         j->cadence_f[lcp->filter].off1min = 0;
5911         j->cadence_f[lcp->filter].off1max = 0;
5912         j->cadence_f[lcp->filter].on2 = lcp->on2;
5913         j->cadence_f[lcp->filter].on2min = 0;
5914         j->cadence_f[lcp->filter].on2max = 0;
5915         j->cadence_f[lcp->filter].off2 = lcp->off2;
5916         j->cadence_f[lcp->filter].off2min = 0;
5917         j->cadence_f[lcp->filter].off2max = 0;
5918         j->cadence_f[lcp->filter].on3 = lcp->on3;
5919         j->cadence_f[lcp->filter].on3min = 0;
5920         j->cadence_f[lcp->filter].on3max = 0;
5921         j->cadence_f[lcp->filter].off3 = lcp->off3;
5922         j->cadence_f[lcp->filter].off3min = 0;
5923         j->cadence_f[lcp->filter].off3max = 0;
5924         if(ixjdebug & 0x0002) {
5925                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5926         }
5927         kfree(lcp);
5928         return 0;
5929 }
5930
5931 static void add_caps(IXJ *j)
5932 {
5933         j->caps = 0;
5934         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5935         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5936         j->caplist[j->caps].captype = vendor;
5937         j->caplist[j->caps].handle = j->caps++;
5938         j->caplist[j->caps].captype = device;
5939         switch (j->cardtype) {
5940         case QTI_PHONEJACK:
5941                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5942                 break;
5943         case QTI_LINEJACK:
5944                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5945                 break;
5946         case QTI_PHONEJACK_LITE:
5947                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5948                 break;
5949         case QTI_PHONEJACK_PCI:
5950                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5951                 break;
5952         case QTI_PHONECARD:
5953                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5954                 break;
5955         }
5956         j->caplist[j->caps].cap = j->cardtype;
5957         j->caplist[j->caps].handle = j->caps++;
5958         strcpy(j->caplist[j->caps].desc, "POTS");
5959         j->caplist[j->caps].captype = port;
5960         j->caplist[j->caps].cap = pots;
5961         j->caplist[j->caps].handle = j->caps++;
5962
5963         /* add devices that can do speaker/mic */
5964         switch (j->cardtype) {
5965         case QTI_PHONEJACK:
5966         case QTI_LINEJACK:
5967         case QTI_PHONEJACK_PCI:
5968         case QTI_PHONECARD:
5969                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5970                 j->caplist[j->caps].captype = port;
5971                 j->caplist[j->caps].cap = speaker;
5972                 j->caplist[j->caps].handle = j->caps++;
5973         default:
5974                 break;
5975         }
5976
5977         /* add devices that can do handset */
5978         switch (j->cardtype) {
5979         case QTI_PHONEJACK:
5980                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5981                 j->caplist[j->caps].captype = port;
5982                 j->caplist[j->caps].cap = handset;
5983                 j->caplist[j->caps].handle = j->caps++;
5984                 break;
5985         default:
5986                 break;
5987         }
5988
5989         /* add devices that can do PSTN */
5990         switch (j->cardtype) {
5991         case QTI_LINEJACK:
5992                 strcpy(j->caplist[j->caps].desc, "PSTN");
5993                 j->caplist[j->caps].captype = port;
5994                 j->caplist[j->caps].cap = pstn;
5995                 j->caplist[j->caps].handle = j->caps++;
5996                 break;
5997         default:
5998                 break;
5999         }
6000
6001         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6002         strcpy(j->caplist[j->caps].desc, "ULAW");
6003         j->caplist[j->caps].captype = codec;
6004         j->caplist[j->caps].cap = ULAW;
6005         j->caplist[j->caps].handle = j->caps++;
6006
6007         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6008         j->caplist[j->caps].captype = codec;
6009         j->caplist[j->caps].cap = LINEAR16;
6010         j->caplist[j->caps].handle = j->caps++;
6011
6012         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6013         j->caplist[j->caps].captype = codec;
6014         j->caplist[j->caps].cap = LINEAR8;
6015         j->caplist[j->caps].handle = j->caps++;
6016
6017         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6018         j->caplist[j->caps].captype = codec;
6019         j->caplist[j->caps].cap = WSS;
6020         j->caplist[j->caps].handle = j->caps++;
6021
6022         /* software ALAW codec, made from ULAW */
6023         strcpy(j->caplist[j->caps].desc, "ALAW");
6024         j->caplist[j->caps].captype = codec;
6025         j->caplist[j->caps].cap = ALAW;
6026         j->caplist[j->caps].handle = j->caps++;
6027
6028         /* version 12 of the 8020 does the following codecs in a broken way */
6029         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6030                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6031                 j->caplist[j->caps].captype = codec;
6032                 j->caplist[j->caps].cap = G723_63;
6033                 j->caplist[j->caps].handle = j->caps++;
6034
6035                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6036                 j->caplist[j->caps].captype = codec;
6037                 j->caplist[j->caps].cap = G723_53;
6038                 j->caplist[j->caps].handle = j->caps++;
6039
6040                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6041                 j->caplist[j->caps].captype = codec;
6042                 j->caplist[j->caps].cap = TS48;
6043                 j->caplist[j->caps].handle = j->caps++;
6044
6045                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6046                 j->caplist[j->caps].captype = codec;
6047                 j->caplist[j->caps].cap = TS41;
6048                 j->caplist[j->caps].handle = j->caps++;
6049         }
6050
6051         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6052         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6053                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6054                 j->caplist[j->caps].captype = codec;
6055                 j->caplist[j->caps].cap = TS85;
6056                 j->caplist[j->caps].handle = j->caps++;
6057         }
6058
6059         /* 8021 chips can do G728 */
6060         if (j->dsp.low == 0x21) {
6061                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6062                 j->caplist[j->caps].captype = codec;
6063                 j->caplist[j->caps].cap = G728;
6064                 j->caplist[j->caps].handle = j->caps++;
6065         }
6066
6067         /* 8021/8022 chips can do G729 if loaded */
6068         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6070                 j->caplist[j->caps].captype = codec;
6071                 j->caplist[j->caps].cap = G729;
6072                 j->caplist[j->caps].handle = j->caps++;
6073         }
6074         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6075                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6076                 j->caplist[j->caps].captype = codec;
6077                 j->caplist[j->caps].cap = G729B;
6078                 j->caplist[j->caps].handle = j->caps++;
6079         }
6080 }
6081
6082 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6083 {
6084         int cnt;
6085         int retval = 0;
6086         for (cnt = 0; cnt < j->caps; cnt++) {
6087                 if (pcreq->captype == j->caplist[cnt].captype
6088                     && pcreq->cap == j->caplist[cnt].cap) {
6089                         retval = 1;
6090                         break;
6091                 }
6092         }
6093         return retval;
6094 }
6095
6096 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6097 {
6098         IXJ_TONE ti;
6099         IXJ_FILTER jf;
6100         IXJ_FILTER_RAW jfr;
6101         void __user *argp = (void __user *)arg;
6102         struct inode *inode = file_p->f_path.dentry->d_inode;
6103         unsigned int minor = iminor(inode);
6104         unsigned int raise, mant;
6105         int board = NUM(inode);
6106
6107         IXJ *j = get_ixj(NUM(inode));
6108
6109         int retval = 0;
6110
6111         /*
6112          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6113          *    This is necessary to keep the DSP from locking up.
6114          */
6115         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6116                 schedule_timeout_interruptible(1);
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 long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6663 {
6664         long ret;
6665         lock_kernel();
6666         ret = do_ixj_ioctl(file_p, cmd, arg);
6667         unlock_kernel();
6668         return ret;
6669 }
6670
6671 static int ixj_fasync(int fd, struct file *file_p, int mode)
6672 {
6673         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6674
6675         return fasync_helper(fd, file_p, mode, &j->async_queue);
6676 }
6677
6678 static const struct file_operations ixj_fops =
6679 {
6680         .owner          = THIS_MODULE,
6681         .read           = ixj_enhanced_read,
6682         .write          = ixj_enhanced_write,
6683         .poll           = ixj_poll,
6684         .unlocked_ioctl = ixj_ioctl,
6685         .release        = ixj_release,
6686         .fasync         = ixj_fasync
6687 };
6688
6689 static int ixj_linetest(IXJ *j)
6690 {
6691         j->flags.pstncheck = 1; /* Testing */
6692         j->flags.pstn_present = 0; /* Assume the line is not there */
6693
6694         daa_int_read(j);        /*Clear DAA Interrupt flags */
6695         /* */
6696         /* Hold all relays in the normally de-energized position. */
6697         /* */
6698
6699         j->pld_slicw.bits.rly1 = 0;
6700         j->pld_slicw.bits.rly2 = 0;
6701         j->pld_slicw.bits.rly3 = 0;
6702         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6703         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6704
6705         outb_p(j->pld_scrw.byte, j->XILINXbase);
6706         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6707         if (j->pld_slicr.bits.potspstn) {
6708                 j->flags.pots_pstn = 1;
6709                 j->flags.pots_correct = 0;
6710                 LED_SetState(0x4, j);
6711         } else {
6712                 j->flags.pots_pstn = 0;
6713                 j->pld_slicw.bits.rly1 = 0;
6714                 j->pld_slicw.bits.rly2 = 0;
6715                 j->pld_slicw.bits.rly3 = 1;
6716                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6717                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6718
6719                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6720                 daa_set_mode(j, SOP_PU_CONVERSATION);
6721                 msleep(1000);
6722                 daa_int_read(j);
6723                 daa_set_mode(j, SOP_PU_RESET);
6724                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6725                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6726                         LED_SetState(0x4, j);
6727                         j->pld_slicw.bits.rly3 = 0;
6728                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6729                 } else {
6730                         j->flags.pots_correct = 1;
6731                         LED_SetState(0x8, j);
6732                         j->pld_slicw.bits.rly1 = 1;
6733                         j->pld_slicw.bits.rly2 = 0;
6734                         j->pld_slicw.bits.rly3 = 0;
6735                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736                 }
6737         }
6738         j->pld_slicw.bits.rly3 = 0;
6739         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6740         daa_set_mode(j, SOP_PU_CONVERSATION);
6741         msleep(1000);
6742         daa_int_read(j);
6743         daa_set_mode(j, SOP_PU_RESET);
6744         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6745                 j->pstn_sleeptil = jiffies + (hertz / 4);
6746                 j->flags.pstn_present = 1;
6747         } else {
6748                 j->flags.pstn_present = 0;
6749         }
6750         if (j->flags.pstn_present) {
6751                 if (j->flags.pots_correct) {
6752                         LED_SetState(0xA, j);
6753                 } else {
6754                         LED_SetState(0x6, j);
6755                 }
6756         } else {
6757                 if (j->flags.pots_correct) {
6758                         LED_SetState(0x9, j);
6759                 } else {
6760                         LED_SetState(0x5, j);
6761                 }
6762         }
6763         j->flags.pstncheck = 0; /* Testing */
6764         return j->flags.pstn_present;
6765 }
6766
6767 static int ixj_selfprobe(IXJ *j)
6768 {
6769         unsigned short cmd;
6770         int cnt;
6771         BYTES bytes;
6772
6773         init_waitqueue_head(&j->poll_q);
6774         init_waitqueue_head(&j->read_q);
6775         init_waitqueue_head(&j->write_q);
6776
6777         while(atomic_read(&j->DSPWrite) > 0)
6778                 atomic_dec(&j->DSPWrite);
6779         if (ixjdebug & 0x0002)
6780                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6781         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6782
6783         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6784                 return -1;
6785 /* The read values of the SSR should be 0x00 for the IDLE command */
6786         if (j->ssr.low || j->ssr.high)
6787                 return -1;
6788         if (ixjdebug & 0x0002)
6789                 printk(KERN_INFO "Get Device ID Code\n");
6790         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6791                 return -1;
6792         j->dsp.low = j->ssr.low;
6793         j->dsp.high = j->ssr.high;
6794         if (ixjdebug & 0x0002)
6795                 printk(KERN_INFO "Get Device Version Code\n");
6796         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6797                 return -1;
6798         j->ver.low = j->ssr.low;
6799         j->ver.high = j->ssr.high;
6800         if (!j->cardtype) {
6801                 if (j->dsp.low == 0x21) {
6802                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6803                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6804 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6805                         bytes.low = inb_p(j->XILINXbase + 0x02);
6806                         if (bytes.low == bytes.high)    /*  Register is read only on */
6807                                 /*  Internet PhoneJack Lite */
6808                          {
6809                                 j->cardtype = QTI_PHONEJACK_LITE;
6810                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6811                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812                                         return -1;
6813                                 }
6814                                 j->pld_slicw.pcib.e1 = 1;
6815                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6816                         } else {
6817                                 j->cardtype = QTI_LINEJACK;
6818
6819                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6820                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6821                                         return -1;
6822                                 }
6823                         }
6824                 } else if (j->dsp.low == 0x22) {
6825                         j->cardtype = QTI_PHONEJACK_PCI;
6826                         request_region(j->XILINXbase, 4, "ixj control");
6827                         j->pld_slicw.pcib.e1 = 1;
6828                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6829                 } else
6830                         j->cardtype = QTI_PHONEJACK;
6831         } else {
6832                 switch (j->cardtype) {
6833                 case QTI_PHONEJACK:
6834                         if (!j->dsp.low != 0x20) {
6835                                 j->dsp.high = 0x80;
6836                                 j->dsp.low = 0x20;
6837                                 ixj_WriteDSPCommand(0x3800, j);
6838                                 j->ver.low = j->ssr.low;
6839                                 j->ver.high = j->ssr.high;
6840                         }
6841                         break;
6842                 case QTI_LINEJACK:
6843                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6844                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6845                                 return -1;
6846                         }
6847                         break;
6848                 case QTI_PHONEJACK_LITE:
6849                 case QTI_PHONEJACK_PCI:
6850                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6851                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6852                                 return -1;
6853                         }
6854                         j->pld_slicw.pcib.e1 = 1;
6855                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6856                         break;
6857                 case QTI_PHONECARD:
6858                         break;
6859                 }
6860         }
6861         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6862                 if (ixjdebug & 0x0002)
6863                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6864                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6865                         return -1;
6866                 if (ixjdebug & 0x0002)
6867                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6868                 if (j->cardtype == QTI_PHONEJACK) {
6869                         cmd = 0x9FF2;
6870                 } else {
6871                         cmd = 0x9FF5;
6872                 }
6873                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6874                         return -1;
6875         } else {
6876                 if (set_base_frame(j, 30) != 30)
6877                         return -1;
6878                 if (ixjdebug & 0x0002)
6879                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6880                 if (j->cardtype == QTI_PHONECARD) {
6881                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6882                                 return -1;
6883                 }
6884                 if (j->cardtype == QTI_LINEJACK) {
6885                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6886                                 return -1;
6887                         if (ixjdebug & 0x0002)
6888                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6889                         j->pld_clock.byte = 0;
6890                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6891                 }
6892         }
6893
6894         if (j->dsp.low == 0x20) {
6895                 if (ixjdebug & 0x0002)
6896                         printk(KERN_INFO "Configure GPIO pins\n");
6897                 j->gpio.bytes.high = 0x09;
6898 /*  bytes.low = 0xEF;  0xF7 */
6899                 j->gpio.bits.gpio1 = 1;
6900                 j->gpio.bits.gpio2 = 1;
6901                 j->gpio.bits.gpio3 = 0;
6902                 j->gpio.bits.gpio4 = 1;
6903                 j->gpio.bits.gpio5 = 1;
6904                 j->gpio.bits.gpio6 = 1;
6905                 j->gpio.bits.gpio7 = 1;
6906                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6907                 if (ixjdebug & 0x0002)
6908                         printk(KERN_INFO "Enable SLIC\n");
6909                 j->gpio.bytes.high = 0x0B;
6910                 j->gpio.bytes.low = 0x00;
6911                 j->gpio.bits.gpio1 = 0;
6912                 j->gpio.bits.gpio2 = 1;
6913                 j->gpio.bits.gpio5 = 0;
6914                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6915                 j->port = PORT_POTS;
6916         } else {
6917                 if (j->cardtype == QTI_LINEJACK) {
6918                         LED_SetState(0x1, j);
6919                         msleep(100);
6920                         LED_SetState(0x2, j);
6921                         msleep(100);
6922                         LED_SetState(0x4, j);
6923                         msleep(100);
6924                         LED_SetState(0x8, j);
6925                         msleep(100);
6926                         LED_SetState(0x0, j);
6927                         daa_get_version(j);
6928                         if (ixjdebug & 0x0002)
6929                                 printk("Loading DAA Coefficients\n");
6930                         DAA_Coeff_US(j);
6931                         if (!ixj_daa_write(j)) {
6932                                 printk("DAA write failed on board %d\n", j->board);
6933                                 return -1;
6934                         }
6935                         if(!ixj_daa_cid_reset(j)) {
6936                                 printk("DAA CID reset failed on board %d\n", j->board);
6937                                 return -1;
6938                         }
6939                         j->flags.pots_correct = 0;
6940                         j->flags.pstn_present = 0;
6941                         ixj_linetest(j);
6942                         if (j->flags.pots_correct) {
6943                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6944
6945                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6946                                 j->pld_slicw.bits.rly1 = 1;
6947                                 j->pld_slicw.bits.spken = 1;
6948                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6949                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6950 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6951                                 j->port = PORT_POTS;
6952                         }
6953                         ixj_set_port(j, PORT_PSTN);
6954                         ixj_set_pots(j, 1);
6955                         if (ixjdebug & 0x0002)
6956                                 printk(KERN_INFO "Enable Mixer\n");
6957                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6958                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6959
6960                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6961                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6962
6963                         ixj_mixer(0x0480, j);   /*FM Left mute */
6964                         ixj_mixer(0x0580, j);   /*FM Right mute */
6965
6966                         ixj_mixer(0x0680, j);   /*CD Left mute */
6967                         ixj_mixer(0x0780, j);   /*CD Right mute */
6968
6969                         ixj_mixer(0x0880, j);   /*Line Left mute */
6970                         ixj_mixer(0x0980, j);   /*Line Right mute */
6971
6972                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6973                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6974
6975                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6976                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6977
6978                         ixj_mixer(0x0E80, j);   /*Mic mute */
6979
6980                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6981
6982                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6983                         ixj_mixer(0x110C, j);
6984
6985
6986                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6987                         ixj_mixer(0x1401, j);
6988
6989                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6990                         ixj_mixer(0x1501, j);
6991
6992                         ixj_mixer(0x1700, j);   /*Clock select */
6993
6994                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6995
6996                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6997
6998                         if (ixjdebug & 0x0002)
6999                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7000                         j->cadence_f[4].state = 0;
7001                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7002                         j->cadence_f[4].off1 = 0;
7003                         j->cadence_f[4].on2 = 0;
7004                         j->cadence_f[4].off2 = 0;
7005                         j->cadence_f[4].on3 = 0;
7006                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7007                         j->pstn_last_rmr = jiffies;
7008
7009                 } else {
7010                         if (j->cardtype == QTI_PHONECARD) {
7011                                 ixj_WriteDSPCommand(0xCF07, j);
7012                                 ixj_WriteDSPCommand(0x00B0, j);
7013                                 ixj_set_port(j, PORT_SPEAKER);
7014                         } else {
7015                                 ixj_set_port(j, PORT_POTS);
7016                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7017 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7018                         }
7019                 }
7020         }
7021
7022         j->intercom = -1;
7023         j->framesread = j->frameswritten = 0;
7024         j->read_wait = j->write_wait = 0;
7025         j->rxreadycheck = j->txreadycheck = 0;
7026
7027         /* initialise the DTMF prescale to a sensible value */
7028         if (j->cardtype == QTI_LINEJACK) {
7029                 set_dtmf_prescale(j, 0x10);
7030         } else {
7031                 set_dtmf_prescale(j, 0x40);
7032         }
7033         set_play_volume(j, 0x100);
7034         set_rec_volume(j, 0x100);
7035
7036         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7037                 return -1;
7038 /* The read values of the SSR should be 0x00 for the IDLE command */
7039         if (j->ssr.low || j->ssr.high)
7040                 return -1;
7041
7042         if (ixjdebug & 0x0002)
7043                 printk(KERN_INFO "Enable Line Monitor\n");
7044
7045         if (ixjdebug & 0x0002)
7046                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7047
7048         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7049                 return -1;
7050
7051         if (ixjdebug & 0x002)
7052                 printk(KERN_INFO "Enable DTMF Detectors\n");
7053
7054         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7055                 return -1;
7056
7057         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7058                 return -1;
7059
7060         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7061
7062         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7063
7064         j->ex.bits.dtmf_ready = 0;
7065         j->dtmf_state = 0;
7066         j->dtmf_wp = j->dtmf_rp = 0;
7067         j->rec_mode = j->play_mode = -1;
7068         j->flags.ringing = 0;
7069         j->maxrings = MAXRINGS;
7070         j->ring_cadence = USA_RING_CADENCE;
7071         j->drybuffer = 0;
7072         j->winktime = 320;
7073         j->flags.dtmf_oob = 0;
7074         for (cnt = 0; cnt < 4; cnt++)
7075                 j->cadence_f[cnt].enable = 0;
7076         /* must be a device on the specified address */
7077         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7078
7079         /* Set up the default signals for events */
7080         for (cnt = 0; cnt < 35; cnt++)
7081                 j->ixj_signals[cnt] = SIGIO;
7082
7083         /* Set the excetion signal enable flags */
7084         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7085         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 =
7086         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;
7087 #ifdef IXJ_DYN_ALLOC
7088         j->fskdata = NULL;
7089 #endif
7090         j->fskdcnt = 0;
7091         j->cidcw_wait = 0;
7092
7093         /* Register with the Telephony for Linux subsystem */
7094         j->p.f_op = &ixj_fops;
7095         j->p.open = ixj_open;
7096         j->p.board = j->board;
7097         phone_register_device(&j->p, PHONE_UNIT_ANY);
7098
7099         ixj_init_timer(j);
7100         ixj_add_timer(j);
7101         return 0;
7102 }
7103
7104 /*
7105  *      Exported service for pcmcia card handling
7106  */
7107
7108 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7109 {
7110         IXJ *j = ixj_alloc();
7111
7112         j->board = 0;
7113
7114         j->DSPbase = dsp;
7115         j->XILINXbase = xilinx;
7116         j->cardtype = QTI_PHONECARD;
7117         ixj_selfprobe(j);
7118         return j;
7119 }
7120
7121 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7122
7123 static int ixj_get_status_proc(char *buf)
7124 {
7125         int len;
7126         int cnt;
7127         IXJ *j;
7128         len = 0;
7129         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7130         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7131         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7132         len += sprintf(buf + len, "\nUsing old telephony API");
7133         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7134
7135         for (cnt = 0; cnt < IXJMAX; cnt++) {
7136                 j = get_ixj(cnt);
7137                 if(j==NULL)
7138                         continue;
7139                 if (j->DSPbase) {
7140                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7141                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7142                         if (j->cardtype != QTI_PHONEJACK)
7143                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7144                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7145                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7146                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7147                         switch (j->cardtype) {
7148                         case (QTI_PHONEJACK):
7149                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7150                                 break;
7151                         case (QTI_LINEJACK):
7152                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7153                                 if (j->flags.g729_loaded)
7154                                         len += sprintf(buf + len, " w/G.729 A/B");
7155                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7156                                 break;
7157                         case (QTI_PHONEJACK_LITE):
7158                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7159                                 if (j->flags.g729_loaded)
7160                                         len += sprintf(buf + len, " w/G.729 A/B");
7161                                 break;
7162                         case (QTI_PHONEJACK_PCI):
7163                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7164                                 if (j->flags.g729_loaded)
7165                                         len += sprintf(buf + len, " w/G.729 A/B");
7166                                 break;
7167                         case (QTI_PHONECARD):
7168                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7169                                 if (j->flags.g729_loaded)
7170                                         len += sprintf(buf + len, " w/G.729 A/B");
7171                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7172                                 if (!j->pccr1.bits.drf)
7173                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7174                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7175                                 break;
7176                         default:
7177                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7178                                 break;
7179                         }
7180                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7181                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7182                         add_caps(j);
7183                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7184                         if (j->dsp.low != 0x20)
7185                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7186                         if (j->flags.cidsent)
7187                                 len += sprintf(buf + len, "\nCaller ID data sent");
7188                         else
7189                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7190
7191                         len += sprintf(buf + len, "\nPlay CODEC ");
7192                         switch (j->play_codec) {
7193                         case G723_63:
7194                                 len += sprintf(buf + len, "G.723.1 6.3");
7195                                 break;
7196                         case G723_53:
7197                                 len += sprintf(buf + len, "G.723.1 5.3");
7198                                 break;
7199                         case TS85:
7200                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7201                                 break;
7202                         case TS48:
7203                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7204                                 break;
7205                         case TS41:
7206                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7207                                 break;
7208                         case G728:
7209                                 len += sprintf(buf + len, "G.728");
7210                                 break;
7211                         case G729:
7212                                 len += sprintf(buf + len, "G.729");
7213                                 break;
7214                         case G729B:
7215                                 len += sprintf(buf + len, "G.729B");
7216                                 break;
7217                         case ULAW:
7218                                 len += sprintf(buf + len, "uLaw");
7219                                 break;
7220                         case ALAW:
7221                                 len += sprintf(buf + len, "aLaw");
7222                                 break;
7223                         case LINEAR16:
7224                                 len += sprintf(buf + len, "16 bit Linear");
7225                                 break;
7226                         case LINEAR8:
7227                                 len += sprintf(buf + len, "8 bit Linear");
7228                                 break;
7229                         case WSS:
7230                                 len += sprintf(buf + len, "Windows Sound System");
7231                                 break;
7232                         default:
7233                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7234                                 break;
7235                         }
7236                         len += sprintf(buf + len, "\nRecord CODEC ");
7237                         switch (j->rec_codec) {
7238                         case G723_63:
7239                                 len += sprintf(buf + len, "G.723.1 6.3");
7240                                 break;
7241                         case G723_53:
7242                                 len += sprintf(buf + len, "G.723.1 5.3");
7243                                 break;
7244                         case TS85:
7245                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7246                                 break;
7247                         case TS48:
7248                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7249                                 break;
7250                         case TS41:
7251                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7252                                 break;
7253                         case G728:
7254                                 len += sprintf(buf + len, "G.728");
7255                                 break;
7256                         case G729:
7257                                 len += sprintf(buf + len, "G.729");
7258                                 break;
7259                         case G729B:
7260                                 len += sprintf(buf + len, "G.729B");
7261                                 break;
7262                         case ULAW:
7263                                 len += sprintf(buf + len, "uLaw");
7264                                 break;
7265                         case ALAW:
7266                                 len += sprintf(buf + len, "aLaw");
7267                                 break;
7268                         case LINEAR16:
7269                                 len += sprintf(buf + len, "16 bit Linear");
7270                                 break;
7271                         case LINEAR8:
7272                                 len += sprintf(buf + len, "8 bit Linear");
7273                                 break;
7274                         case WSS:
7275                                 len += sprintf(buf + len, "Windows Sound System");
7276                                 break;
7277                         default:
7278                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7279                                 break;
7280                         }
7281                         len += sprintf(buf + len, "\nAEC ");
7282                         switch (j->aec_level) {
7283                         case AEC_OFF:
7284                                 len += sprintf(buf + len, "Off");
7285                                 break;
7286                         case AEC_LOW:
7287                                 len += sprintf(buf + len, "Low");
7288                                 break;
7289                         case AEC_MED:
7290                                 len += sprintf(buf + len, "Med");
7291                                 break;
7292                         case AEC_HIGH:
7293                                 len += sprintf(buf + len, "High");
7294                                 break;
7295                         case AEC_AUTO:
7296                                 len += sprintf(buf + len, "Auto");
7297                                 break;
7298                         case AEC_AGC:
7299                                 len += sprintf(buf + len, "AEC/AGC");
7300                                 break;
7301                         default:
7302                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7303                                 break;
7304                         }
7305
7306                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7307                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7308                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7309
7310                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7311
7312                         if (j->cardtype == QTI_LINEJACK) {
7313                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7314                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7315                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7316                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7317                                 switch (j->daa_mode) {
7318                                 case SOP_PU_SLEEP:
7319                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7320                                         break;
7321                                 case SOP_PU_RINGING:
7322                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7323                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7324                                         break;
7325                                 case SOP_PU_CONVERSATION:
7326                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7327                                         break;
7328                                 case SOP_PU_PULSEDIALING:
7329                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7330                                         break;
7331                                 }
7332                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7333                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7334                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7335                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7336                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7337                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7338                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7339                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7340                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7341                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7342                         }
7343                         switch (j->port) {
7344                         case PORT_POTS:
7345                                 len += sprintf(buf + len, "\nPort POTS");
7346                                 break;
7347                         case PORT_PSTN:
7348                                 len += sprintf(buf + len, "\nPort PSTN");
7349                                 break;
7350                         case PORT_SPEAKER:
7351                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7352                                 break;
7353                         case PORT_HANDSET:
7354                                 len += sprintf(buf + len, "\nPort HANDSET");
7355                                 break;
7356                         }
7357                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7358                                 len += sprintf(buf + len, "\nSLIC state ");
7359                                 switch (SLIC_GetState(j)) {
7360                                 case PLD_SLIC_STATE_OC:
7361                                         len += sprintf(buf + len, "OC");
7362                                         break;
7363                                 case PLD_SLIC_STATE_RINGING:
7364                                         len += sprintf(buf + len, "RINGING");
7365                                         break;
7366                                 case PLD_SLIC_STATE_ACTIVE:
7367                                         len += sprintf(buf + len, "ACTIVE");
7368                                         break;
7369                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7370                                         len += sprintf(buf + len, "OHT");
7371                                         break;
7372                                 case PLD_SLIC_STATE_TIPOPEN:
7373                                         len += sprintf(buf + len, "TIPOPEN");
7374                                         break;
7375                                 case PLD_SLIC_STATE_STANDBY:
7376                                         len += sprintf(buf + len, "STANDBY");
7377                                         break;
7378                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7379                                         len += sprintf(buf + len, "APR");
7380                                         break;
7381                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7382                                         len += sprintf(buf + len, "OHTPR");
7383                                         break;
7384                                 default:
7385                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7386                                         break;
7387                                 }
7388                         }
7389                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7390                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7391 #ifdef PERFMON_STATS
7392                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7393                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7394                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7395                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7396                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7397                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7398                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7399                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7400                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7401                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7402                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7403                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7404                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7405                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7406
7407 #endif
7408                         len += sprintf(buf + len, "\n");
7409                 }
7410         }
7411         return len;
7412 }
7413
7414 static int ixj_read_proc(char *page, char **start, off_t off,
7415                               int count, int *eof, void *data)
7416 {
7417         int len = ixj_get_status_proc(page);
7418         if (len <= off+count) *eof = 1;
7419         *start = page + off;
7420         len -= off;
7421         if (len>count) len = count;
7422         if (len<0) len = 0;
7423         return len;
7424 }
7425
7426
7427 static void cleanup(void)
7428 {
7429         int cnt;
7430         IXJ *j;
7431
7432         for (cnt = 0; cnt < IXJMAX; cnt++) {
7433                 j = get_ixj(cnt);
7434                 if(j != NULL && j->DSPbase) {
7435                         if (ixjdebug & 0x0002)
7436                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7437                         del_timer(&j->timer);
7438                         if (j->cardtype == QTI_LINEJACK) {
7439                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7440
7441                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7442                                 j->pld_slicw.bits.rly1 = 0;
7443                                 j->pld_slicw.bits.rly2 = 0;
7444                                 j->pld_slicw.bits.rly3 = 0;
7445                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7446                                 LED_SetState(0x0, j);
7447                                 if (ixjdebug & 0x0002)
7448                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449                                 release_region(j->XILINXbase, 8);
7450                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7451                                 if (ixjdebug & 0x0002)
7452                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7453                                 release_region(j->XILINXbase, 4);
7454                         }
7455                         kfree(j->read_buffer);
7456                         kfree(j->write_buffer);
7457                         if (j->dev)
7458                                 pnp_device_detach(j->dev);
7459                         if (ixjdebug & 0x0002)
7460                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7461                         phone_unregister_device(&j->p);
7462                         if (ixjdebug & 0x0002)
7463                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7464                         release_region(j->DSPbase, 16);
7465 #ifdef IXJ_DYN_ALLOC
7466                         if (ixjdebug & 0x0002)
7467                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7468                         kfree(j);
7469                         ixj[cnt] = NULL;
7470 #endif
7471                 }
7472         }
7473         if (ixjdebug & 0x0002)
7474                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7475         remove_proc_entry ("ixj", NULL);
7476 }
7477
7478 /* Typedefs */
7479 typedef struct {
7480         BYTE length;
7481         DWORD bits;
7482 } DATABLOCK;
7483
7484 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7485 {
7486         lastLCC = lastLCC & 0xfb;
7487         lastLCC = lastLCC | (byData ? 4 : 0);
7488         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7489
7490         mdelay(1);
7491         lastLCC = lastLCC | 0x01;
7492         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7493
7494         byData = byData << 1;
7495         lastLCC = lastLCC & 0xfe;
7496         mdelay(1);
7497         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7498
7499 }
7500
7501 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7502 {
7503         mdelay(1);
7504         lastLCC = lastLCC | 0x01;
7505         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7506
7507         lastLCC = lastLCC & 0xfe;
7508         mdelay(1);
7509         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7510
7511         return ((inb(wEEPROMAddress) >> 3) & 1);
7512 }
7513
7514 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7515 {
7516         BYTE lastLCC;
7517         WORD wEEPROMAddress = wAddress + 3;
7518         DWORD i;
7519         BYTE byResult;
7520         *pwResult = 0;
7521         lastLCC = inb(wEEPROMAddress);
7522         lastLCC = lastLCC | 0x02;
7523         lastLCC = lastLCC & 0xfe;
7524         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7525
7526         mdelay(1);              /* delay */
7527
7528         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7529         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7530         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7531         for (i = 0; i < 8; i++) {
7532                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7533                 wLoc <<= 1;
7534         }
7535
7536         for (i = 0; i < 16; i++) {
7537                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7538                 *pwResult = (*pwResult << 1) | byResult;
7539         }
7540
7541         mdelay(1);              /* another delay */
7542
7543         lastLCC = lastLCC & 0xfd;
7544         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7545
7546         return 0;
7547 }
7548
7549 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7550 {
7551         WORD wLo, wHi;
7552         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7553                 return 0;
7554         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7555                 return 0;
7556         return (((DWORD) wHi << 16) | wLo);
7557 }
7558
7559 static int dspio[IXJMAX + 1] =
7560 {
7561         0,
7562 };
7563 static int xio[IXJMAX + 1] =
7564 {
7565         0,
7566 };
7567
7568 module_param_array(dspio, int, NULL, 0);
7569 module_param_array(xio, int, NULL, 0);
7570 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7571 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7572 MODULE_LICENSE("GPL");
7573
7574 static void __exit ixj_exit(void)
7575 {
7576         cleanup();
7577 }
7578
7579 static IXJ *new_ixj(unsigned long port)
7580 {
7581         IXJ *res;
7582         if (!request_region(port, 16, "ixj DSP")) {
7583                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7584                 return NULL;
7585         }
7586         res = ixj_alloc();
7587         if (!res) {
7588                 release_region(port, 16);
7589                 printk(KERN_INFO "ixj: out of memory\n");
7590                 return NULL;
7591         }
7592         res->DSPbase = port;
7593         return res;
7594 }
7595
7596 static int __init ixj_probe_isapnp(int *cnt)
7597 {
7598         int probe = 0;
7599         int func = 0x110;
7600         struct pnp_dev *dev = NULL, *old_dev = NULL;
7601
7602         while (1) {
7603                 do {
7604                         IXJ *j;
7605                         int result;
7606
7607                         old_dev = dev;
7608                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7609                                          ISAPNP_FUNCTION(func), old_dev);
7610                         if (!dev || !dev->card)
7611                                 break;
7612                         result = pnp_device_attach(dev);
7613                         if (result < 0) {
7614                                 printk("pnp attach failed %d \n", result);
7615                                 break;
7616                         }
7617                         if (pnp_activate_dev(dev) < 0) {
7618                                 printk("pnp activate failed (out of resources?)\n");
7619                                 pnp_device_detach(dev);
7620                                 return -ENOMEM;
7621                         }
7622
7623                         if (!pnp_port_valid(dev, 0)) {
7624                                 pnp_device_detach(dev);
7625                                 return -ENODEV;
7626                         }
7627
7628                         j = new_ixj(pnp_port_start(dev, 0));
7629                         if (!j)
7630                                 break;
7631
7632                         if (func != 0x110)
7633                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7634
7635                         switch (func) {
7636                         case (0x110):
7637                                 j->cardtype = QTI_PHONEJACK;
7638                                 break;
7639                         case (0x310):
7640                                 j->cardtype = QTI_LINEJACK;
7641                                 break;
7642                         case (0x410):
7643                                 j->cardtype = QTI_PHONEJACK_LITE;
7644                                 break;
7645                         }
7646                         j->board = *cnt;
7647                         probe = ixj_selfprobe(j);
7648                         if(!probe) {
7649                                 j->serial = dev->card->serial;
7650                                 j->dev = dev;
7651                                 switch (func) {
7652                                 case 0x110:
7653                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7654                                         break;
7655                                 case 0x310:
7656                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7657                                         break;
7658                                 case 0x410:
7659                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7660                                         break;
7661                                 }
7662                         }
7663                         ++*cnt;
7664                 } while (dev);
7665                 if (func == 0x410)
7666                         break;
7667                 if (func == 0x310)
7668                         func = 0x410;
7669                 if (func == 0x110)
7670                         func = 0x310;
7671                 dev = NULL;
7672         }
7673         return probe;
7674 }
7675
7676 static int __init ixj_probe_isa(int *cnt)
7677 {
7678         int i, probe;
7679
7680         /* Use passed parameters for older kernels without PnP */
7681         for (i = 0; i < IXJMAX; i++) {
7682                 if (dspio[i]) {
7683                         IXJ *j = new_ixj(dspio[i]);
7684
7685                         if (!j)
7686                                 break;
7687
7688                         j->XILINXbase = xio[i];
7689                         j->cardtype = 0;
7690
7691                         j->board = *cnt;
7692                         probe = ixj_selfprobe(j);
7693                         j->dev = NULL;
7694                         ++*cnt;
7695                 }
7696         }
7697         return 0;
7698 }
7699
7700 static int __init ixj_probe_pci(int *cnt)
7701 {
7702         struct pci_dev *pci = NULL;
7703         int i, probe = 0;
7704         IXJ *j = NULL;
7705
7706         for (i = 0; i < IXJMAX - *cnt; i++) {
7707                 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7708                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7709                 if (!pci)
7710                         break;
7711
7712                 if (pci_enable_device(pci))
7713                         break;
7714                 j = new_ixj(pci_resource_start(pci, 0));
7715                 if (!j)
7716                         break;
7717
7718                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7719                 j->XILINXbase = j->DSPbase + 0x10;
7720                 j->cardtype = QTI_PHONEJACK_PCI;
7721                 j->board = *cnt;
7722                 probe = ixj_selfprobe(j);
7723                 if (!probe)
7724                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7725                 ++*cnt;
7726         }
7727         pci_dev_put(pci);
7728         return probe;
7729 }
7730
7731 static int __init ixj_init(void)
7732 {
7733         int cnt = 0;
7734         int probe = 0;
7735
7736         cnt = 0;
7737
7738         /* These might be no-ops, see above. */
7739         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7740                 return probe;
7741         }
7742         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7743                 return probe;
7744         }
7745         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7746                 return probe;
7747         }
7748         printk(KERN_INFO "ixj driver initialized.\n");
7749         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7750         return probe;
7751 }
7752
7753 module_init(ixj_init);
7754 module_exit(ixj_exit);
7755
7756 static void DAA_Coeff_US(IXJ *j)
7757 {
7758         int i;
7759
7760         j->daa_country = DAA_US;
7761         /*----------------------------------------------- */
7762         /* CAO */
7763         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7764                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7765         }
7766
7767 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7772         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7774         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7775         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7776 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7777         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7778         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7779         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7780         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7781         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7782         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7783         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7784         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7785 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7790         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7792         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7793         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7794 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7795         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7796         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7797         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7798         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7799         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7800         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7801         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7802         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7803 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7804         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7805         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7806         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7807         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7808 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7809         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7810         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7811         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7812         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7813 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7822 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7827         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7829         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7830         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7831 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7832         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7833         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7834         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7835         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7836         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7837         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7838         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7839         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7840 /* ;  (10K, 0.68uF) */
7841         /*  */
7842         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7847         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7849         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7850         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7851         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7852         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7853         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7854         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7855         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7856         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7857         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7858         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7859         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7860
7861         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7862         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7863         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7864         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7865         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7866
7867         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7872 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7875 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7876         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7878 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7880 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7881 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7882 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7883 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7884 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7885 /* */
7886         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7887 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7888 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7889 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7890 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7891
7892         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7897         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7899         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7900         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7901 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7902         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7903         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7904         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7905         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7906         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7907         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7908         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7909         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7910 /*  */
7911         /* ;CR Registers */
7912         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7913         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7914 /* Config. Reg. 1 (dialing)       (cr1):05 */
7915         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7916 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7917         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7918 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7919         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7920 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7921         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7922         /* Config. Reg. 5 (Version)       (cr5):02 */
7923         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7924         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7925         /*  */
7926         /* ;xr Registers */
7927         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7928
7929         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7930         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7931
7932         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7933 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7934         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7935 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7936         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7937         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7938
7939         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7940 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7941         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7942 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7943         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7944 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7945         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7946         /*  */
7947         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7948         /*                                       12,33,5A,C3 ;  770 Hz   */
7949         /*                                       13,3C,5B,32 ;  852 Hz   */
7950         /*                                       1D,1B,5C,CC ;  941 Hz   */
7951
7952         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7953         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7954         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7955         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7956 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7957         /*                                       EC,1D,52,22 ;  1336 Hz   */
7958         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7959         /*                                       9B,3B,51,25 ;  1633 Hz   */
7960         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7961         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7962         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7963         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7964 }
7965
7966 static void DAA_Coeff_UK(IXJ *j)
7967 {
7968         int i;
7969
7970         j->daa_country = DAA_UK;
7971         /*----------------------------------------------- */
7972         /* CAO */
7973         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7974                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7975         }
7976
7977 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7982         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7984         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7985         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7986 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7987         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7988         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7989         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7990         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7991         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7992         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7993         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7994         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7995 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8000         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8002         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8003         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8004 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8005         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8006         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8007         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8008         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8009         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8010         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8011         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8012         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8013 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8014         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8015         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8016         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8017         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8018 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8019         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8020         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8021         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8022         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8023 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8032 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8037         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8039         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8040         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8041 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8042         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8043         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8044         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8045         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8046         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8047         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8048         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8049         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8050 /* ; idle */
8051         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8056         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8058         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8059         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8060 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8061         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8062         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8063         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8064         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8065         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8066         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8067         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8068         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8069 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8070         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8071         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8072         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8073         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8074 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8079         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8081         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8082         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8083 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8084         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8085         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8086         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8087         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8088         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8089         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8090         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8091         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8092 /* ;CR Registers */
8093         /* Config. Reg. 0 (filters)        (cr0):FF */
8094         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8095 /* Config. Reg. 1 (dialing)        (cr1):05 */
8096         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8097 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8098         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8099 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8100         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8101 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8102         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8103         /* Config. Reg. 5 (Version)        (cr5):02 */
8104         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8105         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8106         /* ;xr Registers */
8107         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8108
8109         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8110         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8111
8112         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8113         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8114
8115         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8116 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8117         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8118 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8119         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8120 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8121         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8122 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8123         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8124 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8125         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8126         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8127         /*                                       12,33,5A,C3    ;  770 Hz   */
8128         /*                                       13,3C,5B,32    ;  852 Hz   */
8129         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8130
8131         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8132         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8133         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8134         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8135 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8136         /*                                       EC,1D,52,22    ;  1336 Hz   */
8137         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8138         /*                                       9B,3B,51,25    ;  1633 Hz   */
8139         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8140         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8141         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8142         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8143 }
8144
8145
8146 static void DAA_Coeff_France(IXJ *j)
8147 {
8148         int i;
8149
8150         j->daa_country = DAA_FRANCE;
8151         /*----------------------------------------------- */
8152         /* CAO */
8153         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8154                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8155         }
8156
8157 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8162         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8164         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8165         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8166 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8167         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8168         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8169         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8170         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8171         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8172         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8173         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8174         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8175 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8180         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8182         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8183         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8184 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8185         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8186         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8187         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8188         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8189         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8190         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8191         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8192         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8193 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8194         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8195         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8196         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8197         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8198 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8199         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8200         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8201         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8202         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8203 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8212 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8217         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8219         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8220         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8221 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8222         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8223         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8224         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8225         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8226         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8227         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8228         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8229         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8230 /* ; idle */
8231         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8236         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8238         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8239         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8240 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8241         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8242         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8243         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8244         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8245         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8246         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8247         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8248         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8249 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8250         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8251         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8252         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8253         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8254 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8259         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8261         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8262         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8263 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8264         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8265         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8266         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8267         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8268         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8269         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8270         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8271         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8272 /* ;CR Registers */
8273         /* Config. Reg. 0 (filters)        (cr0):FF */
8274         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8275 /* Config. Reg. 1 (dialing)        (cr1):05 */
8276         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8277 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8278         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8279 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8280         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8281 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8282         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8283         /* Config. Reg. 5 (Version)        (cr5):02 */
8284         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8285         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8286         /* ;xr Registers */
8287         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8288
8289         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8290         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8291
8292         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8293         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8294
8295         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8296 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8297         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8298 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8299         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8300 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8301         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8302 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8303         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8304 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8305         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8306         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8307         /*                                       12,33,5A,C3    ;  770 Hz   */
8308         /*                                       13,3C,5B,32    ;  852 Hz   */
8309         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8310
8311         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8312         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8313         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8314         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8315 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8316         /*                                       EC,1D,52,22    ;  1336 Hz   */
8317         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8318         /*                                       9B,3B,51,25    ;  1633 Hz   */
8319         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8320         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8321         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8322         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8323 }
8324
8325
8326 static void DAA_Coeff_Germany(IXJ *j)
8327 {
8328         int i;
8329
8330         j->daa_country = DAA_GERMANY;
8331         /*----------------------------------------------- */
8332         /* CAO */
8333         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8334                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8335         }
8336
8337 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8342         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8344         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8345         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8346 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8347         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8348         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8349         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8350         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8351         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8352         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8353         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8354         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8355 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8360         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8362         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8363         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8364 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8365         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8366         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8367         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8368         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8369         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8370         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8371         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8372         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8373 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8374         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8375         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8376         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8377         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8378 /* Bytes for AR-filter        (09): 72,42,13,4B */
8379         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8380         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8381         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8382         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8383 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8392 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8397         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8399         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8400         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8401 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8402         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8403         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8404         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8405         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8406         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8407         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8408         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8409         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8410 /* ;  (10K, 0.68uF) */
8411         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8416         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8418         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8419         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8420 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8421         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8422         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8423         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8424         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8425         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8426         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8427         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8428         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8429 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8430         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8431         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8432         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8433         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8434 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8439         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8441         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8442         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8443 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8444         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8445         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8446         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8447         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8448         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8449         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8450         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8451         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8452 /* ;CR Registers */
8453         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8454         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8455 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8456         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8457 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8458         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8459 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8460         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8461 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8462         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8463         /* Config. Reg. 5 (Version)        (cr5):02 */
8464         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8465         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8466         /* ;xr Registers */
8467         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8468
8469         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8470         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8471
8472         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8473         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8474
8475         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8476 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8477         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8478 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8479         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8480 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8481         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8482 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8483         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8484 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8485         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8486         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8487         /*                                       12,33,5A,C3    ;  770 Hz   */
8488         /*                                       13,3C,5B,32    ;  852 Hz   */
8489         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8490
8491         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8492         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8493         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8494         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8495 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8496         /*                                       EC,1D,52,22    ;  1336 Hz   */
8497         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8498         /*                                       9B,3B,51,25    ;  1633 Hz   */
8499         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8500         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8501         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8502         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8503 }
8504
8505
8506 static void DAA_Coeff_Australia(IXJ *j)
8507 {
8508         int i;
8509
8510         j->daa_country = DAA_AUSTRALIA;
8511         /*----------------------------------------------- */
8512         /* CAO */
8513         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8514                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8515         }
8516
8517 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8522         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8524         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8525         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8526 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8527         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8528         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8529         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8530         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8531         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8532         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8533         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8534         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8535 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8540         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8542         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8543         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8544 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8545         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8546         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8547         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8548         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8549         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8550         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8551         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8552         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8553 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8554         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8555         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8556         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8557         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8558 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8559         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8560         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8561         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8562         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8563 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8572 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8577         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8579         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8580         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8581 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8582         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8583         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8584         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8585         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8586         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8587         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8588         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8589         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8590 /* ;  idle */
8591         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8596         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8598         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8599         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8600 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8601         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8602         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8603         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8604         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8605         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8606         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8607         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8608         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8609 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8610         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8611         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8612         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8613         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8614 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8619         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8621         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8622         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8623 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8624         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8625         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8626         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8627         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8628         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8629         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8630         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8631         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8632 /* ;CR Registers */
8633         /* Config. Reg. 0 (filters)        (cr0):FF */
8634         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8635 /* Config. Reg. 1 (dialing)        (cr1):05 */
8636         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8637 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8638         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8639 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8640         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8641 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8642         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8643         /* Config. Reg. 5 (Version)        (cr5):02 */
8644         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8645         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8646         /* ;xr Registers */
8647         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8648
8649         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8650         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8651
8652         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8653         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8654
8655         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8656 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8657         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8658 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8659         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8660 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8661         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8662 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8663         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8664 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8665         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8666
8667         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8668         /*                                       12,33,5A,C3    ;  770 Hz   */
8669         /*                                       13,3C,5B,32    ;  852 Hz   */
8670         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8671         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8672         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8673         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8674         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8675
8676         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8677         /*                                       EC,1D,52,22    ;  1336 Hz   */
8678         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8679         /*                                       9B,3B,51,25    ;  1633 Hz   */
8680         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8681         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8682         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8683         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8684 }
8685
8686 static void DAA_Coeff_Japan(IXJ *j)
8687 {
8688         int i;
8689
8690         j->daa_country = DAA_JAPAN;
8691         /*----------------------------------------------- */
8692         /* CAO */
8693         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8694                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8695         }
8696
8697 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8702         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8704         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8705         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8706 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8707         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8708         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8709         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8710         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8711         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8712         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8713         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8714         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8715 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8720         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8722         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8723         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8724 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8725         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8726         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8727         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8728         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8729         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8730         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8731         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8732         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8733 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8734         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8735         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8736         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8737         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8738 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8739         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8740         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8741         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8742         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8743 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8752 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8757         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8759         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8760         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8761 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8762         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8763         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8764         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8765         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8766         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8767         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8768         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8769         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8770 /* ;  idle */
8771         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8776         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8778         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8779         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8780 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8781         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8782         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8783         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8784         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8785         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8786         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8787         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8788         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8789 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8790         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8791         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8792         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8793         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8794 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8799         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8801         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8802         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8803 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8804         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8805         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8806         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8807         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8808         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8809         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8810         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8811         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8812 /* ;CR Registers */
8813         /* Config. Reg. 0 (filters)        (cr0):FF */
8814         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8815 /* Config. Reg. 1 (dialing)        (cr1):05 */
8816         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8817 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8818         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8819 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8820         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8821 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8822         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8823         /* Config. Reg. 5 (Version)        (cr5):02 */
8824         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8825         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8826         /* ;xr Registers */
8827         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8828
8829         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8830         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8831
8832         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8833         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8834
8835         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8836 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8837         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8838 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8839         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8840 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8841         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8842 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8843         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8844 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8845         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8846         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8847         /*                                       12,33,5A,C3    ;  770 Hz   */
8848         /*                                       13,3C,5B,32    ;  852 Hz   */
8849         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8850
8851         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8852         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8853         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8854         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8855 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8856         /*                                       EC,1D,52,22    ;  1336 Hz   */
8857         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8858         /*                                       9B,3B,51,25    ;  1633 Hz   */
8859         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8860         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8861         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8862         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8863 }
8864
8865 static s16 tone_table[][19] =
8866 {
8867         {                       /* f20_50[] 11 */
8868                 32538,          /* A1 = 1.985962 */
8869                  -32325,        /* A2 = -0.986511 */
8870                  -343,          /* B2 = -0.010493 */
8871                  0,             /* B1 = 0 */
8872                  343,           /* B0 = 0.010493 */
8873                  32619,         /* A1 = 1.990906 */
8874                  -32520,        /* A2 = -0.992462 */
8875                  19179,         /* B2 = 0.585327 */
8876                  -19178,        /* B1 = -1.170593 */
8877                  19179,         /* B0 = 0.585327 */
8878                  32723,         /* A1 = 1.997314 */
8879                  -32686,        /* A2 = -0.997528 */
8880                  9973,          /* B2 = 0.304352 */
8881                  -9955,         /* B1 = -0.607605 */
8882                  9973,          /* B0 = 0.304352 */
8883                  7,             /* Internal filter scaling */
8884                  159,           /* Minimum in-band energy threshold */
8885                  21,            /* 21/32 in-band to broad-band ratio */
8886                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8887         },
8888         {                       /* f133_200[] 12 */
8889                 32072,          /* A1 = 1.95752 */
8890                  -31896,        /* A2 = -0.973419 */
8891                  -435,          /* B2 = -0.013294 */
8892                  0,             /* B1 = 0 */
8893                  435,           /* B0 = 0.013294 */
8894                  32188,         /* A1 = 1.9646 */
8895                  -32400,        /* A2 = -0.98877 */
8896                  15139,         /* B2 = 0.462036 */
8897                  -14882,        /* B1 = -0.908356 */
8898                  15139,         /* B0 = 0.462036 */
8899                  32473,         /* A1 = 1.981995 */
8900                  -32524,        /* A2 = -0.992584 */
8901                  23200,         /* B2 = 0.708008 */
8902                  -23113,        /* B1 = -1.410706 */
8903                  23200,         /* B0 = 0.708008 */
8904                  7,             /* Internal filter scaling */
8905                  159,           /* Minimum in-band energy threshold */
8906                  21,            /* 21/32 in-band to broad-band ratio */
8907                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8908         },
8909         {                       /* f300 13 */
8910                 31769,          /* A1 = -1.939026 */
8911                  -32584,        /* A2 = 0.994385 */
8912                  -475,          /* B2 = -0.014522 */
8913                  0,             /* B1 = 0.000000 */
8914                  475,           /* B0 = 0.014522 */
8915                  31789,         /* A1 = -1.940247 */
8916                  -32679,        /* A2 = 0.997284 */
8917                  17280,         /* B2 = 0.527344 */
8918                  -16865,        /* B1 = -1.029358 */
8919                  17280,         /* B0 = 0.527344 */
8920                  31841,         /* A1 = -1.943481 */
8921                  -32681,        /* A2 = 0.997345 */
8922                  543,           /* B2 = 0.016579 */
8923                  -525,          /* B1 = -0.032097 */
8924                  543,           /* B0 = 0.016579 */
8925                  5,             /* Internal filter scaling */
8926                  159,           /* Minimum in-band energy threshold */
8927                  21,            /* 21/32 in-band to broad-band ratio */
8928                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8929         },
8930         {                       /* f300_420[] 14 */
8931                 30750,          /* A1 = 1.876892 */
8932                  -31212,        /* A2 = -0.952515 */
8933                  -804,          /* B2 = -0.024541 */
8934                  0,             /* B1 = 0 */
8935                  804,           /* B0 = 0.024541 */
8936                  30686,         /* A1 = 1.872925 */
8937                  -32145,        /* A2 = -0.980988 */
8938                  14747,         /* B2 = 0.450043 */
8939                  -13703,        /* B1 = -0.836395 */
8940                  14747,         /* B0 = 0.450043 */
8941                  31651,         /* A1 = 1.931824 */
8942                  -32321,        /* A2 = -0.986389 */
8943                  24425,         /* B2 = 0.745422 */
8944                  -23914,        /* B1 = -1.459595 */
8945                  24427,         /* B0 = 0.745483 */
8946                  7,             /* Internal filter scaling */
8947                  159,           /* Minimum in-band energy threshold */
8948                  21,            /* 21/32 in-band to broad-band ratio */
8949                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8950         },
8951         {                       /* f330 15 */
8952                 31613,          /* A1 = -1.929565 */
8953                  -32646,        /* A2 = 0.996277 */
8954                  -185,          /* B2 = -0.005657 */
8955                  0,             /* B1 = 0.000000 */
8956                  185,           /* B0 = 0.005657 */
8957                  31620,         /* A1 = -1.929932 */
8958                  -32713,        /* A2 = 0.998352 */
8959                  19253,         /* B2 = 0.587585 */
8960                  -18566,        /* B1 = -1.133179 */
8961                  19253,         /* B0 = 0.587585 */
8962                  31674,         /* A1 = -1.933228 */
8963                  -32715,        /* A2 = 0.998413 */
8964                  2575,          /* B2 = 0.078590 */
8965                  -2495,         /* B1 = -0.152283 */
8966                  2575,          /* B0 = 0.078590 */
8967                  5,             /* Internal filter scaling */
8968                  159,           /* Minimum in-band energy threshold */
8969                  21,            /* 21/32 in-band to broad-band ratio */
8970                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8971         },
8972         {                       /* f300_425[] 16 */
8973                 30741,          /* A1 = 1.876282 */
8974                  -31475,        /* A2 = -0.960541 */
8975                  -703,          /* B2 = -0.021484 */
8976                  0,             /* B1 = 0 */
8977                  703,           /* B0 = 0.021484 */
8978                  30688,         /* A1 = 1.873047 */
8979                  -32248,        /* A2 = -0.984161 */
8980                  14542,         /* B2 = 0.443787 */
8981                  -13523,        /* B1 = -0.825439 */
8982                  14542,         /* B0 = 0.443817 */
8983                  31494,         /* A1 = 1.922302 */
8984                  -32366,        /* A2 = -0.987762 */
8985                  21577,         /* B2 = 0.658508 */
8986                  -21013,        /* B1 = -1.282532 */
8987                  21577,         /* B0 = 0.658508 */
8988                  7,             /* Internal filter scaling */
8989                  159,           /* Minimum in-band energy threshold */
8990                  21,            /* 21/32 in-band to broad-band ratio */
8991                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8992         },
8993         {                       /* f330_440[] 17 */
8994                 30627,          /* A1 = 1.869324 */
8995                  -31338,        /* A2 = -0.95636 */
8996                  -843,          /* B2 = -0.025749 */
8997                  0,             /* B1 = 0 */
8998                  843,           /* B0 = 0.025749 */
8999                  30550,         /* A1 = 1.864685 */
9000                  -32221,        /* A2 = -0.983337 */
9001                  13594,         /* B2 = 0.414886 */
9002                  -12589,        /* B1 = -0.768402 */
9003                  13594,         /* B0 = 0.414886 */
9004                  31488,         /* A1 = 1.921936 */
9005                  -32358,        /* A2 = -0.987518 */
9006                  24684,         /* B2 = 0.753296 */
9007                  -24029,        /* B1 = -1.466614 */
9008                  24684,         /* B0 = 0.753296 */
9009                  7,             /* Internal filter scaling */
9010                  159,           /* Minimum in-band energy threshold */
9011                  21,            /* 21/32 in-band to broad-band ratio */
9012                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9013         },
9014         {                       /* f340 18 */
9015                 31546,          /* A1 = -1.925476 */
9016                  -32646,        /* A2 = 0.996277 */
9017                  -445,          /* B2 = -0.013588 */
9018                  0,             /* B1 = 0.000000 */
9019                  445,           /* B0 = 0.013588 */
9020                  31551,         /* A1 = -1.925781 */
9021                  -32713,        /* A2 = 0.998352 */
9022                  23884,         /* B2 = 0.728882 */
9023                  -22979,        /* B1 = -1.402527 */
9024                  23884,         /* B0 = 0.728882 */
9025                  31606,         /* A1 = -1.929138 */
9026                  -32715,        /* A2 = 0.998413 */
9027                  863,           /* B2 = 0.026367 */
9028                  -835,          /* B1 = -0.050985 */
9029                  863,           /* B0 = 0.026367 */
9030                  5,             /* Internal filter scaling */
9031                  159,           /* Minimum in-band energy threshold */
9032                  21,            /* 21/32 in-band to broad-band ratio */
9033                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9034         },
9035         {                       /* f350_400[] 19 */
9036                 31006,          /* A1 = 1.892517 */
9037                  -32029,        /* A2 = -0.977448 */
9038                  -461,          /* B2 = -0.014096 */
9039                  0,             /* B1 = 0 */
9040                  461,           /* B0 = 0.014096 */
9041                  30999,         /* A1 = 1.892029 */
9042                  -32487,        /* A2 = -0.991455 */
9043                  11325,         /* B2 = 0.345612 */
9044                  -10682,        /* B1 = -0.651978 */
9045                  11325,         /* B0 = 0.345612 */
9046                  31441,         /* A1 = 1.919067 */
9047                  -32526,        /* A2 = -0.992615 */
9048                  24324,         /* B2 = 0.74231 */
9049                  -23535,        /* B1 = -1.436523 */
9050                  24324,         /* B0 = 0.74231 */
9051                  7,             /* Internal filter scaling */
9052                  159,           /* Minimum in-band energy threshold */
9053                  21,            /* 21/32 in-band to broad-band ratio */
9054                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9055         },
9056         {                       /* f350_440[] */
9057                 30634,          /* A1 = 1.869751 */
9058                  -31533,        /* A2 = -0.962341 */
9059                  -680,          /* B2 = -0.020782 */
9060                  0,             /* B1 = 0 */
9061                  680,           /* B0 = 0.020782 */
9062                  30571,         /* A1 = 1.865906 */
9063                  -32277,        /* A2 = -0.985016 */
9064                  12894,         /* B2 = 0.393524 */
9065                  -11945,        /* B1 = -0.729065 */
9066                  12894,         /* B0 = 0.393524 */
9067                  31367,         /* A1 = 1.91449 */
9068                  -32379,        /* A2 = -0.988129 */
9069                  23820,         /* B2 = 0.726929 */
9070                  -23104,        /* B1 = -1.410217 */
9071                  23820,         /* B0 = 0.726929 */
9072                  7,             /* Internal filter scaling */
9073                  159,           /* Minimum in-band energy threshold */
9074                  21,            /* 21/32 in-band to broad-band ratio */
9075                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9076         },
9077         {                       /* f350_450[] */
9078                 30552,          /* A1 = 1.864807 */
9079                  -31434,        /* A2 = -0.95929 */
9080                  -690,          /* B2 = -0.021066 */
9081                  0,             /* B1 = 0 */
9082                  690,           /* B0 = 0.021066 */
9083                  30472,         /* A1 = 1.859924 */
9084                  -32248,        /* A2 = -0.984161 */
9085                  13385,         /* B2 = 0.408478 */
9086                  -12357,        /* B1 = -0.754242 */
9087                  13385,         /* B0 = 0.408478 */
9088                  31358,         /* A1 = 1.914001 */
9089                  -32366,        /* A2 = -0.987732 */
9090                  26488,         /* B2 = 0.80835 */
9091                  -25692,        /* B1 = -1.568176 */
9092                  26490,         /* B0 = 0.808411 */
9093                  7,             /* Internal filter scaling */
9094                  159,           /* Minimum in-band energy threshold */
9095                  21,            /* 21/32 in-band to broad-band ratio */
9096                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9097         },
9098         {                       /* f360 */
9099                 31397,          /* A1 = -1.916321 */
9100                  -32623,        /* A2 = 0.995605 */
9101                  -117,          /* B2 = -0.003598 */
9102                  0,             /* B1 = 0.000000 */
9103                  117,           /* B0 = 0.003598 */
9104                  31403,         /* A1 = -1.916687 */
9105                  -32700,        /* A2 = 0.997925 */
9106                  3388,          /* B2 = 0.103401 */
9107                  -3240,         /* B1 = -0.197784 */
9108                  3388,          /* B0 = 0.103401 */
9109                  31463,         /* A1 = -1.920410 */
9110                  -32702,        /* A2 = 0.997986 */
9111                  13346,         /* B2 = 0.407288 */
9112                  -12863,        /* B1 = -0.785126 */
9113                  13346,         /* B0 = 0.407288 */
9114                  5,             /* Internal filter scaling */
9115                  159,           /* Minimum in-band energy threshold */
9116                  21,            /* 21/32 in-band to broad-band ratio */
9117                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9118         },
9119         {                       /* f380_420[] */
9120                 30831,          /* A1 = 1.881775 */
9121                  -32064,        /* A2 = -0.978546 */
9122                  -367,          /* B2 = -0.01122 */
9123                  0,             /* B1 = 0 */
9124                  367,           /* B0 = 0.01122 */
9125                  30813,         /* A1 = 1.880737 */
9126                  -32456,        /* A2 = -0.990509 */
9127                  11068,         /* B2 = 0.337769 */
9128                  -10338,        /* B1 = -0.631042 */
9129                  11068,         /* B0 = 0.337769 */
9130                  31214,         /* A1 = 1.905212 */
9131                  -32491,        /* A2 = -0.991577 */
9132                  16374,         /* B2 = 0.499695 */
9133                  -15781,        /* B1 = -0.963196 */
9134                  16374,         /* B0 = 0.499695 */
9135                  7,             /* Internal filter scaling */
9136                  159,           /* Minimum in-band energy threshold */
9137                  21,            /* 21/32 in-band to broad-band ratio */
9138                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9139         },
9140         {                       /* f392 */
9141                 31152,          /* A1 = -1.901428 */
9142                  -32613,        /* A2 = 0.995300 */
9143                  -314,          /* B2 = -0.009605 */
9144                  0,             /* B1 = 0.000000 */
9145                  314,           /* B0 = 0.009605 */
9146                  31156,         /* A1 = -1.901672 */
9147                  -32694,        /* A2 = 0.997742 */
9148                  28847,         /* B2 = 0.880371 */
9149                  -2734,         /* B1 = -0.166901 */
9150                  28847,         /* B0 = 0.880371 */
9151                  31225,         /* A1 = -1.905823 */
9152                  -32696,        /* A2 = 0.997803 */
9153                  462,           /* B2 = 0.014108 */
9154                  -442,          /* B1 = -0.027019 */
9155                  462,           /* B0 = 0.014108 */
9156                  5,             /* Internal filter scaling */
9157                  159,           /* Minimum in-band energy threshold */
9158                  21,            /* 21/32 in-band to broad-band ratio */
9159                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9160         },
9161         {                       /* f400_425[] */
9162                 30836,          /* A1 = 1.882141 */
9163                  -32296,        /* A2 = -0.985596 */
9164                  -324,          /* B2 = -0.009903 */
9165                  0,             /* B1 = 0 */
9166                  324,           /* B0 = 0.009903 */
9167                  30825,         /* A1 = 1.881409 */
9168                  -32570,        /* A2 = -0.993958 */
9169                  16847,         /* B2 = 0.51416 */
9170                  -15792,        /* B1 = -0.963898 */
9171                  16847,         /* B0 = 0.51416 */
9172                  31106,         /* A1 = 1.89856 */
9173                  -32584,        /* A2 = -0.994415 */
9174                  9579,          /* B2 = 0.292328 */
9175                  -9164,         /* B1 = -0.559357 */
9176                  9579,          /* B0 = 0.292328 */
9177                  7,             /* Internal filter scaling */
9178                  159,           /* Minimum in-band energy threshold */
9179                  21,            /* 21/32 in-band to broad-band ratio */
9180                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9181         },
9182         {                       /* f400_440[] */
9183                 30702,          /* A1 = 1.873962 */
9184                  -32134,        /* A2 = -0.980682 */
9185                  -517,          /* B2 = -0.015793 */
9186                  0,             /* B1 = 0 */
9187                  517,           /* B0 = 0.015793 */
9188                  30676,         /* A1 = 1.872375 */
9189                  -32520,        /* A2 = -0.992462 */
9190                  8144,          /* B2 = 0.24855 */
9191                  -7596,         /* B1 = -0.463684 */
9192                  8144,          /* B0 = 0.24855 */
9193                  31084,         /* A1 = 1.897217 */
9194                  -32547,        /* A2 = -0.993256 */
9195                  22713,         /* B2 = 0.693176 */
9196                  -21734,        /* B1 = -1.326599 */
9197                  22713,         /* B0 = 0.693176 */
9198                  7,             /* Internal filter scaling */
9199                  159,           /* Minimum in-band energy threshold */
9200                  21,            /* 21/32 in-band to broad-band ratio */
9201                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9202         },
9203         {                       /* f400_450[] */
9204                 30613,          /* A1 = 1.86853 */
9205                  -32031,        /* A2 = -0.977509 */
9206                  -618,          /* B2 = -0.018866 */
9207                  0,             /* B1 = 0 */
9208                  618,           /* B0 = 0.018866 */
9209                  30577,         /* A1 = 1.866272 */
9210                  -32491,        /* A2 = -0.991577 */
9211                  9612,          /* B2 = 0.293335 */
9212                  -8935,         /* B1 = -0.54541 */
9213                  9612,          /* B0 = 0.293335 */
9214                  31071,         /* A1 = 1.896484 */
9215                  -32524,        /* A2 = -0.992584 */
9216                  21596,         /* B2 = 0.659058 */
9217                  -20667,        /* B1 = -1.261414 */
9218                  21596,         /* B0 = 0.659058 */
9219                  7,             /* Internal filter scaling */
9220                  159,           /* Minimum in-band energy threshold */
9221                  21,            /* 21/32 in-band to broad-band ratio */
9222                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9223         },
9224         {                       /* f420 */
9225                 30914,          /* A1 = -1.886841 */
9226                  -32584,        /* A2 = 0.994385 */
9227                  -426,          /* B2 = -0.013020 */
9228                  0,             /* B1 = 0.000000 */
9229                  426,           /* B0 = 0.013020 */
9230                  30914,         /* A1 = -1.886841 */
9231                  -32679,        /* A2 = 0.997314 */
9232                  17520,         /* B2 = 0.534668 */
9233                  -16471,        /* B1 = -1.005310 */
9234                  17520,         /* B0 = 0.534668 */
9235                  31004,         /* A1 = -1.892334 */
9236                  -32683,        /* A2 = 0.997406 */
9237                  819,           /* B2 = 0.025023 */
9238                  -780,          /* B1 = -0.047619 */
9239                  819,           /* B0 = 0.025023 */
9240                  5,             /* Internal filter scaling */
9241                  159,           /* Minimum in-band energy threshold */
9242                  21,            /* 21/32 in-band to broad-band ratio */
9243                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9244         },
9245 #if 0
9246         {                       /* f425 */
9247                 30881,          /* A1 = -1.884827 */
9248                  -32603,        /* A2 = 0.994965 */
9249                  -496,          /* B2 = -0.015144 */
9250                  0,             /* B1 = 0.000000 */
9251                  496,           /* B0 = 0.015144 */
9252                  30880,         /* A1 = -1.884766 */
9253                  -32692,        /* A2 = 0.997711 */
9254                  24767,         /* B2 = 0.755859 */
9255                  -23290,        /* B1 = -1.421509 */
9256                  24767,         /* B0 = 0.755859 */
9257                  30967,         /* A1 = -1.890076 */
9258                  -32694,        /* A2 = 0.997772 */
9259                  728,           /* B2 = 0.022232 */
9260                  -691,          /* B1 = -0.042194 */
9261                  728,           /* B0 = 0.022232 */
9262                  5,             /* Internal filter scaling */
9263                  159,           /* Minimum in-band energy threshold */
9264                  21,            /* 21/32 in-band to broad-band ratio */
9265                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9266         },
9267 #else
9268         {
9269                 30850,
9270                 -32534,
9271                 -504,
9272                 0,
9273                 504,
9274                 30831,
9275                 -32669,
9276                 24303,
9277                 -22080,
9278                 24303,
9279                 30994,
9280                 -32673,
9281                 1905,
9282                 -1811,
9283                 1905,
9284                 5,
9285                 129,
9286                 17,
9287                 0xff5
9288         },
9289 #endif
9290         {                       /* f425_450[] */
9291                 30646,          /* A1 = 1.870544 */
9292                  -32327,        /* A2 = -0.986572 */
9293                  -287,          /* B2 = -0.008769 */
9294                  0,             /* B1 = 0 */
9295                  287,           /* B0 = 0.008769 */
9296                  30627,         /* A1 = 1.869324 */
9297                  -32607,        /* A2 = -0.995087 */
9298                  13269,         /* B2 = 0.404968 */
9299                  -12376,        /* B1 = -0.755432 */
9300                  13269,         /* B0 = 0.404968 */
9301                  30924,         /* A1 = 1.887512 */
9302                  -32619,        /* A2 = -0.995453 */
9303                  19950,         /* B2 = 0.608826 */
9304                  -18940,        /* B1 = -1.156006 */
9305                  19950,         /* B0 = 0.608826 */
9306                  7,             /* Internal filter scaling */
9307                  159,           /* Minimum in-band energy threshold */
9308                  21,            /* 21/32 in-band to broad-band ratio */
9309                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9310         },
9311         {                       /* f425_475[] */
9312                 30396,          /* A1 = 1.855225 */
9313                  -32014,        /* A2 = -0.97699 */
9314                  -395,          /* B2 = -0.012055 */
9315                  0,             /* B1 = 0 */
9316                  395,           /* B0 = 0.012055 */
9317                  30343,         /* A1 = 1.85199 */
9318                  -32482,        /* A2 = -0.991302 */
9319                  17823,         /* B2 = 0.543945 */
9320                  -16431,        /* B1 = -1.002869 */
9321                  17823,         /* B0 = 0.543945 */
9322                  30872,         /* A1 = 1.884338 */
9323                  -32516,        /* A2 = -0.99231 */
9324                  18124,         /* B2 = 0.553101 */
9325                  -17246,        /* B1 = -1.052673 */
9326                  18124,         /* B0 = 0.553101 */
9327                  7,             /* Internal filter scaling */
9328                  159,           /* Minimum in-band energy threshold */
9329                  21,            /* 21/32 in-band to broad-band ratio */
9330                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9331         },
9332         {                       /* f435 */
9333                 30796,          /* A1 = -1.879639 */
9334                  -32603,        /* A2 = 0.994965 */
9335                  -254,          /* B2 = -0.007762 */
9336                  0,             /* B1 = 0.000000 */
9337                  254,           /* B0 = 0.007762 */
9338                  30793,         /* A1 = -1.879456 */
9339                  -32692,        /* A2 = 0.997711 */
9340                  18934,         /* B2 = 0.577820 */
9341                  -17751,        /* B1 = -1.083496 */
9342                  18934,         /* B0 = 0.577820 */
9343                  30882,         /* A1 = -1.884888 */
9344                  -32694,        /* A2 = 0.997772 */
9345                  1858,          /* B2 = 0.056713 */
9346                  -1758,         /* B1 = -0.107357 */
9347                  1858,          /* B0 = 0.056713 */
9348                  5,             /* Internal filter scaling */
9349                  159,           /* Minimum in-band energy threshold */
9350                  21,            /* 21/32 in-band to broad-band ratio */
9351                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9352         },
9353         {                       /* f440_450[] */
9354                 30641,          /* A1 = 1.870239 */
9355                  -32458,        /* A2 = -0.99057 */
9356                  -155,          /* B2 = -0.004735 */
9357                  0,             /* B1 = 0 */
9358                  155,           /* B0 = 0.004735 */
9359                  30631,         /* A1 = 1.869568 */
9360                  -32630,        /* A2 = -0.995789 */
9361                  11453,         /* B2 = 0.349548 */
9362                  -10666,        /* B1 = -0.651001 */
9363                  11453,         /* B0 = 0.349548 */
9364                  30810,         /* A1 = 1.880554 */
9365                  -32634,        /* A2 = -0.995941 */
9366                  12237,         /* B2 = 0.373474 */
9367                  -11588,        /* B1 = -0.707336 */
9368                  12237,         /* B0 = 0.373474 */
9369                  7,             /* Internal filter scaling */
9370                  159,           /* Minimum in-band energy threshold */
9371                  21,            /* 21/32 in-band to broad-band ratio */
9372                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9373         },
9374         {                       /* f440_480[] */
9375                 30367,          /* A1 = 1.853455 */
9376                  -32147,        /* A2 = -0.981079 */
9377                  -495,          /* B2 = -0.015113 */
9378                  0,             /* B1 = 0 */
9379                  495,           /* B0 = 0.015113 */
9380                  30322,         /* A1 = 1.850769 */
9381                  -32543,        /* A2 = -0.993134 */
9382                  10031,         /* B2 = 0.306152 */
9383                  -9252,         /* B1 = -0.564728 */
9384                  10031,         /* B0 = 0.306152 */
9385                  30770,         /* A1 = 1.878052 */
9386                  -32563,        /* A2 = -0.993774 */
9387                  22674,         /* B2 = 0.691956 */
9388                  -21465,        /* B1 = -1.31012 */
9389                  22674,         /* B0 = 0.691956 */
9390                  7,             /* Internal filter scaling */
9391                  159,           /* Minimum in-band energy threshold */
9392                  21,            /* 21/32 in-band to broad-band ratio */
9393                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394         },
9395         {                       /* f445 */
9396                 30709,          /* A1 = -1.874329 */
9397                  -32603,        /* A2 = 0.994965 */
9398                  -83,           /* B2 = -0.002545 */
9399                  0,             /* B1 = 0.000000 */
9400                  83,            /* B0 = 0.002545 */
9401                  30704,         /* A1 = -1.874084 */
9402                  -32692,        /* A2 = 0.997711 */
9403                  10641,         /* B2 = 0.324738 */
9404                  -9947,         /* B1 = -0.607147 */
9405                  10641,         /* B0 = 0.324738 */
9406                  30796,         /* A1 = -1.879639 */
9407                  -32694,        /* A2 = 0.997772 */
9408                  10079,         /* B2 = 0.307587 */
9409                  9513,          /* B1 = 0.580688 */
9410                  10079,         /* B0 = 0.307587 */
9411                  5,             /* Internal filter scaling */
9412                  159,           /* Minimum in-band energy threshold */
9413                  21,            /* 21/32 in-band to broad-band ratio */
9414                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9415         },
9416         {                       /* f450 */
9417                 30664,          /* A1 = -1.871643 */
9418                  -32603,        /* A2 = 0.994965 */
9419                  -164,          /* B2 = -0.005029 */
9420                  0,             /* B1 = 0.000000 */
9421                  164,           /* B0 = 0.005029 */
9422                  30661,         /* A1 = -1.871399 */
9423                  -32692,        /* A2 = 0.997711 */
9424                  15294,         /* B2 = 0.466736 */
9425                  -14275,        /* B1 = -0.871307 */
9426                  15294,         /* B0 = 0.466736 */
9427                  30751,         /* A1 = -1.876953 */
9428                  -32694,        /* A2 = 0.997772 */
9429                  3548,          /* B2 = 0.108284 */
9430                  -3344,         /* B1 = -0.204155 */
9431                  3548,          /* B0 = 0.108284 */
9432                  5,             /* Internal filter scaling */
9433                  159,           /* Minimum in-band energy threshold */
9434                  21,            /* 21/32 in-band to broad-band ratio */
9435                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9436         },
9437         {                       /* f452 */
9438                 30653,          /* A1 = -1.870911 */
9439                  -32615,        /* A2 = 0.995361 */
9440                  -209,          /* B2 = -0.006382 */
9441                  0,             /* B1 = 0.000000 */
9442                  209,           /* B0 = 0.006382 */
9443                  30647,         /* A1 = -1.870605 */
9444                  -32702,        /* A2 = 0.997986 */
9445                  18971,         /* B2 = 0.578979 */
9446                  -17716,        /* B1 = -1.081299 */
9447                  18971,         /* B0 = 0.578979 */
9448                  30738,         /* A1 = -1.876099 */
9449                  -32702,        /* A2 = 0.998016 */
9450                  2967,          /* B2 = 0.090561 */
9451                  -2793,         /* B1 = -0.170502 */
9452                  2967,          /* B0 = 0.090561 */
9453                  5,             /* Internal filter scaling */
9454                  159,           /* Minimum in-band energy threshold */
9455                  21,            /* 21/32 in-band to broad-band ratio */
9456                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9457         },
9458         {                       /* f475 */
9459                 30437,          /* A1 = -1.857727 */
9460                  -32603,        /* A2 = 0.994965 */
9461                  -264,          /* B2 = -0.008062 */
9462                  0,             /* B1 = 0.000000 */
9463                  264,           /* B0 = 0.008062 */
9464                  30430,         /* A1 = -1.857300 */
9465                  -32692,        /* A2 = 0.997711 */
9466                  21681,         /* B2 = 0.661682 */
9467                  -20082,        /* B1 = -1.225708 */
9468                  21681,         /* B0 = 0.661682 */
9469                  30526,         /* A1 = -1.863220 */
9470                  -32694,        /* A2 = 0.997742 */
9471                  1559,          /* B2 = 0.047600 */
9472                  -1459,         /* B1 = -0.089096 */
9473                  1559,          /* B0 = 0.047600 */
9474                  5,             /* Internal filter scaling */
9475                  159,           /* Minimum in-band energy threshold */
9476                  21,            /* 21/32 in-band to broad-band ratio */
9477                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9478         },
9479         {                       /* f480_620[] */
9480                 28975,          /* A1 = 1.768494 */
9481                  -30955,        /* A2 = -0.944672 */
9482                  -1026,         /* B2 = -0.03133 */
9483                  0,             /* B1 = 0 */
9484                  1026,          /* B0 = 0.03133 */
9485                  28613,         /* A1 = 1.746399 */
9486                  -32089,        /* A2 = -0.979309 */
9487                  14214,         /* B2 = 0.433807 */
9488                  -12202,        /* B1 = -0.744812 */
9489                  14214,         /* B0 = 0.433807 */
9490                  30243,         /* A1 = 1.845947 */
9491                  -32238,        /* A2 = -0.983856 */
9492                  24825,         /* B2 = 0.757629 */
9493                  -23402,        /* B1 = -1.428345 */
9494                  24825,         /* B0 = 0.757629 */
9495                  7,             /* Internal filter scaling */
9496                  159,           /* Minimum in-band energy threshold */
9497                  21,            /* 21/32 in-band to broad-band ratio */
9498                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9499         },
9500         {                       /* f494 */
9501                 30257,          /* A1 = -1.846741 */
9502                  -32605,        /* A2 = 0.995056 */
9503                  -249,          /* B2 = -0.007625 */
9504                  0,             /* B1 = 0.000000 */
9505                  249,           /* B0 = 0.007625 */
9506                  30247,         /* A1 = -1.846191 */
9507                  -32694,        /* A2 = 0.997772 */
9508                  18088,         /* B2 = 0.552002 */
9509                  -16652,        /* B1 = -1.016418 */
9510                  18088,         /* B0 = 0.552002 */
9511                  30348,         /* A1 = -1.852295 */
9512                  -32696,        /* A2 = 0.997803 */
9513                  2099,          /* B2 = 0.064064 */
9514                  -1953,         /* B1 = -0.119202 */
9515                  2099,          /* B0 = 0.064064 */
9516                  5,             /* Internal filter scaling */
9517                  159,           /* Minimum in-band energy threshold */
9518                  21,            /* 21/32 in-band to broad-band ratio */
9519                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9520         },
9521         {                       /* f500 */
9522                 30202,          /* A1 = -1.843431 */
9523                  -32624,        /* A2 = 0.995622 */
9524                  -413,          /* B2 = -0.012622 */
9525                  0,             /* B1 = 0.000000 */
9526                  413,           /* B0 = 0.012622 */
9527                  30191,         /* A1 = -1.842721 */
9528                  -32714,        /* A2 = 0.998364 */
9529                  25954,         /* B2 = 0.792057 */
9530                  -23890,        /* B1 = -1.458131 */
9531                  25954,         /* B0 = 0.792057 */
9532                  30296,         /* A1 = -1.849172 */
9533                  -32715,        /* A2 = 0.998397 */
9534                  2007,          /* B2 = 0.061264 */
9535                  -1860,         /* B1 = -0.113568 */
9536                  2007,          /* B0 = 0.061264 */
9537                  5,             /* Internal filter scaling */
9538                  159,           /* Minimum in-band energy threshold */
9539                  21,            /* 21/32 in-band to broad-band ratio */
9540                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9541         },
9542         {                       /* f520 */
9543                 30001,          /* A1 = -1.831116 */
9544                  -32613,        /* A2 = 0.995270 */
9545                  -155,          /* B2 = -0.004750 */
9546                  0,             /* B1 = 0.000000 */
9547                  155,           /* B0 = 0.004750 */
9548                  29985,         /* A1 = -1.830200 */
9549                  -32710,        /* A2 = 0.998260 */
9550                  6584,          /* B2 = 0.200928 */
9551                  -6018,         /* B1 = -0.367355 */
9552                  6584,          /* B0 = 0.200928 */
9553                  30105,         /* A1 = -1.837524 */
9554                  -32712,        /* A2 = 0.998291 */
9555                  23812,         /* B2 = 0.726685 */
9556                  -21936,        /* B1 = -1.338928 */
9557                  23812,         /* B0 = 0.726685 */
9558                  5,             /* Internal filter scaling */
9559                  159,           /* Minimum in-band energy threshold */
9560                  21,            /* 21/32 in-band to broad-band ratio */
9561                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9562         },
9563         {                       /* f523 */
9564                 29964,          /* A1 = -1.828918 */
9565                  -32601,        /* A2 = 0.994904 */
9566                  -101,          /* B2 = -0.003110 */
9567                  0,             /* B1 = 0.000000 */
9568                  101,           /* B0 = 0.003110 */
9569                  29949,         /* A1 = -1.827942 */
9570                  -32700,        /* A2 = 0.997925 */
9571                  11041,         /* B2 = 0.336975 */
9572                  -10075,        /* B1 = -0.614960 */
9573                  11041,         /* B0 = 0.336975 */
9574                  30070,         /* A1 = -1.835388 */
9575                  -32702,        /* A2 = 0.997986 */
9576                  16762,         /* B2 = 0.511536 */
9577                  -15437,        /* B1 = -0.942230 */
9578                  16762,         /* B0 = 0.511536 */
9579                  5,             /* Internal filter scaling */
9580                  159,           /* Minimum in-band energy threshold */
9581                  21,            /* 21/32 in-band to broad-band ratio */
9582                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9583         },
9584         {                       /* f525 */
9585                 29936,          /* A1 = -1.827209 */
9586                  -32584,        /* A2 = 0.994415 */
9587                  -91,           /* B2 = -0.002806 */
9588                  0,             /* B1 = 0.000000 */
9589                  91,            /* B0 = 0.002806 */
9590                  29921,         /* A1 = -1.826233 */
9591                  -32688,        /* A2 = 0.997559 */
9592                  11449,         /* B2 = 0.349396 */
9593                  -10426,        /* B1 = -0.636383 */
9594                  11449,         /* B0 = 0.349396 */
9595                  30045,         /* A1 = -1.833862 */
9596                  -32688,        /* A2 = 0.997589 */
9597                  13055,         /* B2 = 0.398407 */
9598                  -12028,        /* B1 = -0.734161 */
9599                  13055,         /* B0 = 0.398407 */
9600                  5,             /* Internal filter scaling */
9601                  159,           /* Minimum in-band energy threshold */
9602                  21,            /* 21/32 in-band to broad-band ratio */
9603                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9604         },
9605         {                       /* f540_660[] */
9606                 28499,          /* A1 = 1.739441 */
9607                  -31129,        /* A2 = -0.949982 */
9608                  -849,          /* B2 = -0.025922 */
9609                  0,             /* B1 = 0 */
9610                  849,           /* B0 = 0.025922 */
9611                  28128,         /* A1 = 1.716797 */
9612                  -32130,        /* A2 = -0.98056 */
9613                  14556,         /* B2 = 0.444214 */
9614                  -12251,        /* B1 = -0.747772 */
9615                  14556,         /* B0 = 0.444244 */
9616                  29667,         /* A1 = 1.81073 */
9617                  -32244,        /* A2 = -0.984039 */
9618                  23038,         /* B2 = 0.703064 */
9619                  -21358,        /* B1 = -1.303589 */
9620                  23040,         /* B0 = 0.703125 */
9621                  7,             /* Internal filter scaling */
9622                  159,           /* Minimum in-band energy threshold */
9623                  21,            /* 21/32 in-band to broad-band ratio */
9624                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9625         },
9626         {                       /* f587 */
9627                 29271,          /* A1 = -1.786560 */
9628                  -32599,        /* A2 = 0.994873 */
9629                  -490,          /* B2 = -0.014957 */
9630                  0,             /* B1 = 0.000000 */
9631                  490,           /* B0 = 0.014957 */
9632                  29246,         /* A1 = -1.785095 */
9633                  -32700,        /* A2 = 0.997925 */
9634                  28961,         /* B2 = 0.883850 */
9635                  -25796,        /* B1 = -1.574463 */
9636                  28961,         /* B0 = 0.883850 */
9637                  29383,         /* A1 = -1.793396 */
9638                  -32700,        /* A2 = 0.997955 */
9639                  1299,          /* B2 = 0.039650 */
9640                  -1169,         /* B1 = -0.071396 */
9641                  1299,          /* B0 = 0.039650 */
9642                  5,             /* Internal filter scaling */
9643                  159,           /* Minimum in-band energy threshold */
9644                  21,            /* 21/32 in-band to broad-band ratio */
9645                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9646         },
9647         {                       /* f590 */
9648                 29230,          /* A1 = -1.784058 */
9649                  -32584,        /* A2 = 0.994415 */
9650                  -418,          /* B2 = -0.012757 */
9651                  0,             /* B1 = 0.000000 */
9652                  418,           /* B0 = 0.012757 */
9653                  29206,         /* A1 = -1.782593 */
9654                  -32688,        /* A2 = 0.997559 */
9655                  36556,         /* B2 = 1.115601 */
9656                  -32478,        /* B1 = -1.982300 */
9657                  36556,         /* B0 = 1.115601 */
9658                  29345,         /* A1 = -1.791077 */
9659                  -32688,        /* A2 = 0.997589 */
9660                  897,           /* B2 = 0.027397 */
9661                  -808,          /* B1 = -0.049334 */
9662                  897,           /* B0 = 0.027397 */
9663                  5,             /* Internal filter scaling */
9664                  159,           /* Minimum in-band energy threshold */
9665                  21,            /* 21/32 in-band to broad-band ratio */
9666                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9667         },
9668         {                       /* f600 */
9669                 29116,          /* A1 = -1.777100 */
9670                  -32603,        /* A2 = 0.994965 */
9671                  -165,          /* B2 = -0.005039 */
9672                  0,             /* B1 = 0.000000 */
9673                  165,           /* B0 = 0.005039 */
9674                  29089,         /* A1 = -1.775452 */
9675                  -32708,        /* A2 = 0.998199 */
9676                  6963,          /* B2 = 0.212494 */
9677                  -6172,         /* B1 = -0.376770 */
9678                  6963,          /* B0 = 0.212494 */
9679                  29237,         /* A1 = -1.784485 */
9680                  -32710,        /* A2 = 0.998230 */
9681                  24197,         /* B2 = 0.738464 */
9682                  -21657,        /* B1 = -1.321899 */
9683                  24197,         /* B0 = 0.738464 */
9684                  5,             /* Internal filter scaling */
9685                  159,           /* Minimum in-band energy threshold */
9686                  21,            /* 21/32 in-band to broad-band ratio */
9687                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9688         },
9689         {                       /* f660 */
9690                 28376,          /* A1 = -1.731934 */
9691                  -32567,        /* A2 = 0.993896 */
9692                  -363,          /* B2 = -0.011102 */
9693                  0,             /* B1 = 0.000000 */
9694                  363,           /* B0 = 0.011102 */
9695                  28337,         /* A1 = -1.729614 */
9696                  -32683,        /* A2 = 0.997434 */
9697                  21766,         /* B2 = 0.664246 */
9698                  -18761,        /* B1 = -1.145081 */
9699                  21766,         /* B0 = 0.664246 */
9700                  28513,         /* A1 = -1.740356 */
9701                  -32686,        /* A2 = 0.997498 */
9702                  2509,          /* B2 = 0.076584 */
9703                  -2196,         /* B1 = -0.134041 */
9704                  2509,          /* B0 = 0.076584 */
9705                  5,             /* Internal filter scaling */
9706                  159,           /* Minimum in-band energy threshold */
9707                  21,            /* 21/32 in-band to broad-band ratio */
9708                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9709         },
9710         {                       /* f700 */
9711                 27844,          /* A1 = -1.699463 */
9712                  -32563,        /* A2 = 0.993744 */
9713                  -366,          /* B2 = -0.011187 */
9714                  0,             /* B1 = 0.000000 */
9715                  366,           /* B0 = 0.011187 */
9716                  27797,         /* A1 = -1.696655 */
9717                  -32686,        /* A2 = 0.997498 */
9718                  22748,         /* B2 = 0.694214 */
9719                  -19235,        /* B1 = -1.174072 */
9720                  22748,         /* B0 = 0.694214 */
9721                  27995,         /* A1 = -1.708740 */
9722                  -32688,        /* A2 = 0.997559 */
9723                  2964,          /* B2 = 0.090477 */
9724                  -2546,         /* B1 = -0.155449 */
9725                  2964,          /* B0 = 0.090477 */
9726                  5,             /* Internal filter scaling */
9727                  159,           /* Minimum in-band energy threshold */
9728                  21,            /* 21/32 in-band to broad-band ratio */
9729                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9730         },
9731         {                       /* f740 */
9732                 27297,          /* A1 = -1.666077 */
9733                  -32551,        /* A2 = 0.993408 */
9734                  -345,          /* B2 = -0.010540 */
9735                  0,             /* B1 = 0.000000 */
9736                  345,           /* B0 = 0.010540 */
9737                  27240,         /* A1 = -1.662598 */
9738                  -32683,        /* A2 = 0.997406 */
9739                  22560,         /* B2 = 0.688477 */
9740                  -18688,        /* B1 = -1.140625 */
9741                  22560,         /* B0 = 0.688477 */
9742                  27461,         /* A1 = -1.676147 */
9743                  -32684,        /* A2 = 0.997467 */
9744                  3541,          /* B2 = 0.108086 */
9745                  -2985,         /* B1 = -0.182220 */
9746                  3541,          /* B0 = 0.108086 */
9747                  5,             /* Internal filter scaling */
9748                  159,           /* Minimum in-band energy threshold */
9749                  21,            /* 21/32 in-band to broad-band ratio */
9750                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9751         },
9752         {                       /* f750 */
9753                 27155,          /* A1 = -1.657410 */
9754                  -32551,        /* A2 = 0.993408 */
9755                  -462,          /* B2 = -0.014117 */
9756                  0,             /* B1 = 0.000000 */
9757                  462,           /* B0 = 0.014117 */
9758                  27097,         /* A1 = -1.653870 */
9759                  -32683,        /* A2 = 0.997406 */
9760                  32495,         /* B2 = 0.991699 */
9761                  -26776,        /* B1 = -1.634338 */
9762                  32495,         /* B0 = 0.991699 */
9763                  27321,         /* A1 = -1.667542 */
9764                  -32684,        /* A2 = 0.997467 */
9765                  1835,          /* B2 = 0.056007 */
9766                  -1539,         /* B1 = -0.093948 */
9767                  1835,          /* B0 = 0.056007 */
9768                  5,             /* Internal filter scaling */
9769                  159,           /* Minimum in-band energy threshold */
9770                  21,            /* 21/32 in-band to broad-band ratio */
9771                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9772         },
9773         {                       /* f750_1450[] */
9774                 19298,          /* A1 = 1.177917 */
9775                  -24471,        /* A2 = -0.746796 */
9776                  -4152,         /* B2 = -0.126709 */
9777                  0,             /* B1 = 0 */
9778                  4152,          /* B0 = 0.126709 */
9779                  12902,         /* A1 = 0.787476 */
9780                  -29091,        /* A2 = -0.887817 */
9781                  12491,         /* B2 = 0.38121 */
9782                  -1794,         /* B1 = -0.109528 */
9783                  12494,         /* B0 = 0.381317 */
9784                  26291,         /* A1 = 1.604736 */
9785                  -30470,        /* A2 = -0.929901 */
9786                  28859,         /* B2 = 0.880737 */
9787                  -26084,        /* B1 = -1.592102 */
9788                  28861,         /* B0 = 0.880798 */
9789                  7,             /* Internal filter scaling */
9790                  159,           /* Minimum in-band energy threshold */
9791                  21,            /* 21/32 in-band to broad-band ratio */
9792                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9793         },
9794         {                       /* f770 */
9795                 26867,          /* A1 = -1.639832 */
9796                  -32551,        /* A2 = 0.993408 */
9797                  -123,          /* B2 = -0.003755 */
9798                  0,             /* B1 = 0.000000 */
9799                  123,           /* B0 = 0.003755 */
9800                  26805,         /* A1 = -1.636108 */
9801                  -32683,        /* A2 = 0.997406 */
9802                  17297,         /* B2 = 0.527863 */
9803                  -14096,        /* B1 = -0.860382 */
9804                  17297,         /* B0 = 0.527863 */
9805                  27034,         /* A1 = -1.650085 */
9806                  -32684,        /* A2 = 0.997467 */
9807                  12958,         /* B2 = 0.395477 */
9808                  -10756,        /* B1 = -0.656525 */
9809                  12958,         /* B0 = 0.395477 */
9810                  5,             /* Internal filter scaling */
9811                  159,           /* Minimum in-band energy threshold */
9812                  21,            /* 21/32 in-band to broad-band ratio */
9813                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9814         },
9815         {                       /* f800 */
9816                 26413,          /* A1 = -1.612122 */
9817                  -32547,        /* A2 = 0.993286 */
9818                  -223,          /* B2 = -0.006825 */
9819                  0,             /* B1 = 0.000000 */
9820                  223,           /* B0 = 0.006825 */
9821                  26342,         /* A1 = -1.607849 */
9822                  -32686,        /* A2 = 0.997498 */
9823                  6391,          /* B2 = 0.195053 */
9824                  -5120,         /* B1 = -0.312531 */
9825                  6391,          /* B0 = 0.195053 */
9826                  26593,         /* A1 = -1.623108 */
9827                  -32688,        /* A2 = 0.997559 */
9828                  23681,         /* B2 = 0.722717 */
9829                  -19328,        /* B1 = -1.179688 */
9830                  23681,         /* B0 = 0.722717 */
9831                  5,             /* Internal filter scaling */
9832                  159,           /* Minimum in-band energy threshold */
9833                  21,            /* 21/32 in-band to broad-band ratio */
9834                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9835         },
9836         {                       /* f816 */
9837                 26168,          /* A1 = -1.597209 */
9838                  -32528,        /* A2 = 0.992706 */
9839                  -235,          /* B2 = -0.007182 */
9840                  0,             /* B1 = 0.000000 */
9841                  235,           /* B0 = 0.007182 */
9842                  26092,         /* A1 = -1.592590 */
9843                  -32675,        /* A2 = 0.997192 */
9844                  20823,         /* B2 = 0.635498 */
9845                  -16510,        /* B1 = -1.007751 */
9846                  20823,         /* B0 = 0.635498 */
9847                  26363,         /* A1 = -1.609070 */
9848                  -32677,        /* A2 = 0.997253 */
9849                  6739,          /* B2 = 0.205688 */
9850                  -5459,         /* B1 = -0.333206 */
9851                  6739,          /* B0 = 0.205688 */
9852                  5,             /* Internal filter scaling */
9853                  159,           /* Minimum in-band energy threshold */
9854                  21,            /* 21/32 in-band to broad-band ratio */
9855                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9856         },
9857         {                       /* f850 */
9858                 25641,          /* A1 = -1.565063 */
9859                  -32536,        /* A2 = 0.992950 */
9860                  -121,          /* B2 = -0.003707 */
9861                  0,             /* B1 = 0.000000 */
9862                  121,           /* B0 = 0.003707 */
9863                  25560,         /* A1 = -1.560059 */
9864                  -32684,        /* A2 = 0.997437 */
9865                  18341,         /* B2 = 0.559753 */
9866                  -14252,        /* B1 = -0.869904 */
9867                  18341,         /* B0 = 0.559753 */
9868                  25837,         /* A1 = -1.577026 */
9869                  -32684,        /* A2 = 0.997467 */
9870                  16679,         /* B2 = 0.509003 */
9871                  -13232,        /* B1 = -0.807648 */
9872                  16679,         /* B0 = 0.509003 */
9873                  5,             /* Internal filter scaling */
9874                  159,           /* Minimum in-band energy threshold */
9875                  21,            /* 21/32 in-band to broad-band ratio */
9876                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9877         },
9878         {                       /* f857_1645[] */
9879                 16415,          /* A1 = 1.001953 */
9880                  -23669,        /* A2 = -0.722321 */
9881                  -4549,         /* B2 = -0.138847 */
9882                  0,             /* B1 = 0 */
9883                  4549,          /* B0 = 0.138847 */
9884                  8456,          /* A1 = 0.516174 */
9885                  -28996,        /* A2 = -0.884918 */
9886                  13753,         /* B2 = 0.419724 */
9887                  -12,           /* B1 = -0.000763 */
9888                  13757,         /* B0 = 0.419846 */
9889                  24632,         /* A1 = 1.503418 */
9890                  -30271,        /* A2 = -0.923828 */
9891                  29070,         /* B2 = 0.887146 */
9892                  -25265,        /* B1 = -1.542114 */
9893                  29073,         /* B0 = 0.887268 */
9894                  7,             /* Internal filter scaling */
9895                  159,           /* Minimum in-band energy threshold */
9896                  21,            /* 21/32 in-band to broad-band ratio */
9897                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9898         },
9899         {                       /* f900 */
9900                 24806,          /* A1 = -1.514099 */
9901                  -32501,        /* A2 = 0.991852 */
9902                  -326,          /* B2 = -0.009969 */
9903                  0,             /* B1 = 0.000000 */
9904                  326,           /* B0 = 0.009969 */
9905                  24709,         /* A1 = -1.508118 */
9906                  -32659,        /* A2 = 0.996674 */
9907                  20277,         /* B2 = 0.618835 */
9908                  -15182,        /* B1 = -0.926636 */
9909                  20277,         /* B0 = 0.618835 */
9910                  25022,         /* A1 = -1.527222 */
9911                  -32661,        /* A2 = 0.996735 */
9912                  4320,          /* B2 = 0.131836 */
9913                  -3331,         /* B1 = -0.203339 */
9914                  4320,          /* B0 = 0.131836 */
9915                  5,             /* Internal filter scaling */
9916                  159,           /* Minimum in-band energy threshold */
9917                  21,            /* 21/32 in-band to broad-band ratio */
9918                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9919         },
9920         {                       /* f900_1300[] */
9921                 19776,          /* A1 = 1.207092 */
9922                  -27437,        /* A2 = -0.837341 */
9923                  -2666,         /* B2 = -0.081371 */
9924                  0,             /* B1 = 0 */
9925                  2666,          /* B0 = 0.081371 */
9926                  16302,         /* A1 = 0.995026 */
9927                  -30354,        /* A2 = -0.926361 */
9928                  10389,         /* B2 = 0.317062 */
9929                  -3327,         /* B1 = -0.203064 */
9930                  10389,         /* B0 = 0.317062 */
9931                  24299,         /* A1 = 1.483154 */
9932                  -30930,        /* A2 = -0.943909 */
9933                  25016,         /* B2 = 0.763428 */
9934                  -21171,        /* B1 = -1.292236 */
9935                  25016,         /* B0 = 0.763428 */
9936                  7,             /* Internal filter scaling */
9937                  159,           /* Minimum in-band energy threshold */
9938                  21,            /* 21/32 in-band to broad-band ratio */
9939                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9940         },
9941         {                       /* f935_1215[] */
9942                 20554,          /* A1 = 1.254517 */
9943                  -28764,        /* A2 = -0.877838 */
9944                  -2048,         /* B2 = -0.062515 */
9945                  0,             /* B1 = 0 */
9946                  2048,          /* B0 = 0.062515 */
9947                  18209,         /* A1 = 1.11145 */
9948                  -30951,        /* A2 = -0.94458 */
9949                  9390,          /* B2 = 0.286575 */
9950                  -3955,         /* B1 = -0.241455 */
9951                  9390,          /* B0 = 0.286575 */
9952                  23902,         /* A1 = 1.458923 */
9953                  -31286,        /* A2 = -0.954803 */
9954                  23252,         /* B2 = 0.709595 */
9955                  -19132,        /* B1 = -1.167725 */
9956                  23252,         /* B0 = 0.709595 */
9957                  7,             /* Internal filter scaling */
9958                  159,           /* Minimum in-band energy threshold */
9959                  21,            /* 21/32 in-band to broad-band ratio */
9960                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9961         },
9962         {                       /* f941_1477[] */
9963                 17543,          /* A1 = 1.07074 */
9964                  -26220,        /* A2 = -0.800201 */
9965                  -3298,         /* B2 = -0.100647 */
9966                  0,             /* B1 = 0 */
9967                  3298,          /* B0 = 0.100647 */
9968                  12423,         /* A1 = 0.75827 */
9969                  -30036,        /* A2 = -0.916626 */
9970                  12651,         /* B2 = 0.386078 */
9971                  -2444,         /* B1 = -0.14917 */
9972                  12653,         /* B0 = 0.386154 */
9973                  23518,         /* A1 = 1.435425 */
9974                  -30745,        /* A2 = -0.938293 */
9975                  27282,         /* B2 = 0.832581 */
9976                  -22529,        /* B1 = -1.375122 */
9977                  27286,         /* B0 = 0.832703 */
9978                  7,             /* Internal filter scaling */
9979                  159,           /* Minimum in-band energy threshold */
9980                  21,            /* 21/32 in-band to broad-band ratio */
9981                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9982         },
9983         {                       /* f942 */
9984                 24104,          /* A1 = -1.471252 */
9985                  -32507,        /* A2 = 0.992065 */
9986                  -351,          /* B2 = -0.010722 */
9987                  0,             /* B1 = 0.000000 */
9988                  351,           /* B0 = 0.010722 */
9989                  23996,         /* A1 = -1.464600 */
9990                  -32671,        /* A2 = 0.997040 */
9991                  22848,         /* B2 = 0.697266 */
9992                  -16639,        /* B1 = -1.015564 */
9993                  22848,         /* B0 = 0.697266 */
9994                  24332,         /* A1 = -1.485168 */
9995                  -32673,        /* A2 = 0.997101 */
9996                  4906,          /* B2 = 0.149727 */
9997                  -3672,         /* B1 = -0.224174 */
9998                  4906,          /* B0 = 0.149727 */
9999                  5,             /* Internal filter scaling */
10000                  159,           /* Minimum in-band energy threshold */
10001                  21,            /* 21/32 in-band to broad-band ratio */
10002                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10003         },
10004         {                       /* f950 */
10005                 23967,          /* A1 = -1.462830 */
10006                  -32507,        /* A2 = 0.992065 */
10007                  -518,          /* B2 = -0.015821 */
10008                  0,             /* B1 = 0.000000 */
10009                  518,           /* B0 = 0.015821 */
10010                  23856,         /* A1 = -1.456055 */
10011                  -32671,        /* A2 = 0.997040 */
10012                  26287,         /* B2 = 0.802246 */
10013                  -19031,        /* B1 = -1.161560 */
10014                  26287,         /* B0 = 0.802246 */
10015                  24195,         /* A1 = -1.476746 */
10016                  -32673,        /* A2 = 0.997101 */
10017                  2890,          /* B2 = 0.088196 */
10018                  -2151,         /* B1 = -0.131317 */
10019                  2890,          /* B0 = 0.088196 */
10020                  5,             /* Internal filter scaling */
10021                  159,           /* Minimum in-band energy threshold */
10022                  21,            /* 21/32 in-band to broad-band ratio */
10023                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10024         },
10025         {                       /* f950_1400[] */
10026                 18294,          /* A1 = 1.116638 */
10027                  -26962,        /* A2 = -0.822845 */
10028                  -2914,         /* B2 = -0.088936 */
10029                  0,             /* B1 = 0 */
10030                  2914,          /* B0 = 0.088936 */
10031                  14119,         /* A1 = 0.861786 */
10032                  -30227,        /* A2 = -0.922455 */
10033                  11466,         /* B2 = 0.349945 */
10034                  -2833,         /* B1 = -0.172943 */
10035                  11466,         /* B0 = 0.349945 */
10036                  23431,         /* A1 = 1.430115 */
10037                  -30828,        /* A2 = -0.940796 */
10038                  25331,         /* B2 = 0.773071 */
10039                  -20911,        /* B1 = -1.276367 */
10040                  25331,         /* B0 = 0.773071 */
10041                  7,             /* Internal filter scaling */
10042                  159,           /* Minimum in-band energy threshold */
10043                  21,            /* 21/32 in-band to broad-band ratio */
10044                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10045         },
10046         {                       /* f975 */
10047                 23521,          /* A1 = -1.435608 */
10048                  -32489,        /* A2 = 0.991516 */
10049                  -193,          /* B2 = -0.005915 */
10050                  0,             /* B1 = 0.000000 */
10051                  193,           /* B0 = 0.005915 */
10052                  23404,         /* A1 = -1.428467 */
10053                  -32655,        /* A2 = 0.996582 */
10054                  17740,         /* B2 = 0.541412 */
10055                  -12567,        /* B1 = -0.767029 */
10056                  17740,         /* B0 = 0.541412 */
10057                  23753,         /* A1 = -1.449829 */
10058                  -32657,        /* A2 = 0.996613 */
10059                  9090,          /* B2 = 0.277405 */
10060                  -6662,         /* B1 = -0.406647 */
10061                  9090,          /* B0 = 0.277405 */
10062                  5,             /* Internal filter scaling */
10063                  159,           /* Minimum in-band energy threshold */
10064                  21,            /* 21/32 in-band to broad-band ratio */
10065                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10066         },
10067         {                       /* f1000 */
10068                 23071,          /* A1 = -1.408203 */
10069                  -32489,        /* A2 = 0.991516 */
10070                  -293,          /* B2 = -0.008965 */
10071                  0,             /* B1 = 0.000000 */
10072                  293,           /* B0 = 0.008965 */
10073                  22951,         /* A1 = -1.400818 */
10074                  -32655,        /* A2 = 0.996582 */
10075                  5689,          /* B2 = 0.173645 */
10076                  -3951,         /* B1 = -0.241150 */
10077                  5689,          /* B0 = 0.173645 */
10078                  23307,         /* A1 = -1.422607 */
10079                  -32657,        /* A2 = 0.996613 */
10080                  18692,         /* B2 = 0.570435 */
10081                  -13447,        /* B1 = -0.820770 */
10082                  18692,         /* B0 = 0.570435 */
10083                  5,             /* Internal filter scaling */
10084                  159,           /* Minimum in-band energy threshold */
10085                  21,            /* 21/32 in-band to broad-band ratio */
10086                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10087         },
10088         {                       /* f1020 */
10089                 22701,          /* A1 = -1.385620 */
10090                  -32474,        /* A2 = 0.991058 */
10091                  -292,          /* B2 = -0.008933 */
10092                  0,             /*163840      , B1 = 10.000000 */
10093                  292,           /* B0 = 0.008933 */
10094                  22564,         /* A1 = -1.377258 */
10095                  -32655,        /* A2 = 0.996552 */
10096                  20756,         /* B2 = 0.633423 */
10097                  -14176,        /* B1 = -0.865295 */
10098                  20756,         /* B0 = 0.633423 */
10099                  22960,         /* A1 = -1.401428 */
10100                  -32657,        /* A2 = 0.996613 */
10101                  6520,          /* B2 = 0.198990 */
10102                  -4619,         /* B1 = -0.281937 */
10103                  6520,          /* B0 = 0.198990 */
10104                  5,             /* Internal filter scaling */
10105                  159,           /* Minimum in-band energy threshold */
10106                  21,            /* 21/32 in-band to broad-band ratio */
10107                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10108         },
10109         {                       /* f1050 */
10110                 22142,          /* A1 = -1.351501 */
10111                  -32474,        /* A2 = 0.991058 */
10112                  -147,          /* B2 = -0.004493 */
10113                  0,             /* B1 = 0.000000 */
10114                  147,           /* B0 = 0.004493 */
10115                  22000,         /* A1 = -1.342834 */
10116                  -32655,        /* A2 = 0.996552 */
10117                  15379,         /* B2 = 0.469360 */
10118                  -10237,        /* B1 = -0.624847 */
10119                  15379,         /* B0 = 0.469360 */
10120                  22406,         /* A1 = -1.367554 */
10121                  -32657,        /* A2 = 0.996613 */
10122                  17491,         /* B2 = 0.533783 */
10123                  -12096,        /* B1 = -0.738312 */
10124                  17491,         /* B0 = 0.533783 */
10125                  5,             /* Internal filter scaling */
10126                  159,           /* Minimum in-band energy threshold */
10127                  21,            /* 21/32 in-band to broad-band ratio */
10128                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10129         },
10130         {                       /* f1100_1750[] */
10131                 12973,          /* A1 = 0.79184 */
10132                  -24916,        /* A2 = -0.760376 */
10133                  6655,          /* B2 = 0.203102 */
10134                  367,           /* B1 = 0.0224 */
10135                  6657,          /* B0 = 0.203171 */
10136                  5915,          /* A1 = 0.361053 */
10137                  -29560,        /* A2 = -0.90213 */
10138                  -7777,         /* B2 = -0.23735 */
10139                  0,             /* B1 = 0 */
10140                  7777,          /* B0 = 0.23735 */
10141                  20510,         /* A1 = 1.251892 */
10142                  -30260,        /* A2 = -0.923462 */
10143                  26662,         /* B2 = 0.81366 */
10144                  -20573,        /* B1 = -1.255737 */
10145                  26668,         /* B0 = 0.813843 */
10146                  7,             /* Internal filter scaling */
10147                  159,           /* Minimum in-band energy threshold */
10148                  21,            /* 21/32 in-band to broad-band ratio */
10149                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10150         },
10151         {                       /* f1140 */
10152                 20392,          /* A1 = -1.244629 */
10153                  -32460,        /* A2 = 0.990601 */
10154                  -270,          /* B2 = -0.008240 */
10155                  0,             /* B1 = 0.000000 */
10156                  270,           /* B0 = 0.008240 */
10157                  20218,         /* A1 = -1.234009 */
10158                  -32655,        /* A2 = 0.996582 */
10159                  21337,         /* B2 = 0.651154 */
10160                  -13044,        /* B1 = -0.796143 */
10161                  21337,         /* B0 = 0.651154 */
10162                  20684,         /* A1 = -1.262512 */
10163                  -32657,        /* A2 = 0.996643 */
10164                  8572,          /* B2 = 0.261612 */
10165                  -5476,         /* B1 = -0.334244 */
10166                  8572,          /* B0 = 0.261612 */
10167                  5,             /* Internal filter scaling */
10168                  159,           /* Minimum in-band energy threshold */
10169                  21,            /* 21/32 in-band to broad-band ratio */
10170                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10171         },
10172         {                       /* f1200 */
10173                 19159,          /* A1 = -1.169373 */
10174                  -32456,        /* A2 = 0.990509 */
10175                  -335,          /* B2 = -0.010252 */
10176                  0,             /* B1 = 0.000000 */
10177                  335,           /* B0 = 0.010252 */
10178                  18966,         /* A1 = -1.157593 */
10179                  -32661,        /* A2 = 0.996735 */
10180                  6802,          /* B2 = 0.207588 */
10181                  -3900,         /* B1 = -0.238098 */
10182                  6802,          /* B0 = 0.207588 */
10183                  19467,         /* A1 = -1.188232 */
10184                  -32661,        /* A2 = 0.996765 */
10185                  25035,         /* B2 = 0.764008 */
10186                  -15049,        /* B1 = -0.918579 */
10187                  25035,         /* B0 = 0.764008 */
10188                  5,             /* Internal filter scaling */
10189                  159,           /* Minimum in-band energy threshold */
10190                  21,            /* 21/32 in-band to broad-band ratio */
10191                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10192         },
10193         {                       /* f1209 */
10194                 18976,          /* A1 = -1.158264 */
10195                  -32439,        /* A2 = 0.989990 */
10196                  -183,          /* B2 = -0.005588 */
10197                  0,             /* B1 = 0.000000 */
10198                  183,           /* B0 = 0.005588 */
10199                  18774,         /* A1 = -1.145874 */
10200                  -32650,        /* A2 = 0.996429 */
10201                  15468,         /* B2 = 0.472076 */
10202                  -8768,         /* B1 = -0.535217 */
10203                  15468,         /* B0 = 0.472076 */
10204                  19300,         /* A1 = -1.177979 */
10205                  -32652,        /* A2 = 0.996490 */
10206                  19840,         /* B2 = 0.605499 */
10207                  -11842,        /* B1 = -0.722809 */
10208                  19840,         /* B0 = 0.605499 */
10209                  5,             /* Internal filter scaling */
10210                  159,           /* Minimum in-band energy threshold */
10211                  21,            /* 21/32 in-band to broad-band ratio */
10212                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10213         },
10214         {                       /* f1330 */
10215                 16357,          /* A1 = -0.998413 */
10216                  -32368,        /* A2 = 0.987793 */
10217                  -217,          /* B2 = -0.006652 */
10218                  0,             /* B1 = 0.000000 */
10219                  217,           /* B0 = 0.006652 */
10220                  16107,         /* A1 = -0.983126 */
10221                  -32601,        /* A2 = 0.994904 */
10222                  11602,         /* B2 = 0.354065 */
10223                  -5555,         /* B1 = -0.339111 */
10224                  11602,         /* B0 = 0.354065 */
10225                  16722,         /* A1 = -1.020630 */
10226                  -32603,        /* A2 = 0.994965 */
10227                  15574,         /* B2 = 0.475311 */
10228                  -8176,         /* B1 = -0.499069 */
10229                  15574,         /* B0 = 0.475311 */
10230                  5,             /* Internal filter scaling */
10231                  159,           /* Minimum in-band energy threshold */
10232                  21,            /* 21/32 in-band to broad-band ratio */
10233                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10234         },
10235         {                       /* f1336 */
10236                 16234,          /* A1 = -0.990875 */
10237                  32404,         /* A2 = -0.988922 */
10238                  -193,          /* B2 = -0.005908 */
10239                  0,             /* B1 = 0.000000 */
10240                  193,           /* B0 = 0.005908 */
10241                  15986,         /* A1 = -0.975769 */
10242                  -32632,        /* A2 = 0.995880 */
10243                  18051,         /* B2 = 0.550903 */
10244                  -8658,         /* B1 = -0.528473 */
10245                  18051,         /* B0 = 0.550903 */
10246                  16591,         /* A1 = -1.012695 */
10247                  -32634,        /* A2 = 0.995941 */
10248                  15736,         /* B2 = 0.480240 */
10249                  -8125,         /* B1 = -0.495926 */
10250                  15736,         /* B0 = 0.480240 */
10251                  5,             /* Internal filter scaling */
10252                  159,           /* Minimum in-band energy threshold */
10253                  21,            /* 21/32 in-band to broad-band ratio */
10254                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10255         },
10256         {                       /* f1366 */
10257                 15564,          /* A1 = -0.949982 */
10258                  -32404,        /* A2 = 0.988922 */
10259                  -269,          /* B2 = -0.008216 */
10260                  0,             /* B1 = 0.000000 */
10261                  269,           /* B0 = 0.008216 */
10262                  15310,         /* A1 = -0.934479 */
10263                  -32632,        /* A2 = 0.995880 */
10264                  10815,         /* B2 = 0.330063 */
10265                  -4962,         /* B1 = -0.302887 */
10266                  10815,         /* B0 = 0.330063 */
10267                  15924,         /* A1 = -0.971924 */
10268                  -32634,        /* A2 = 0.995941 */
10269                  18880,         /* B2 = 0.576172 */
10270                  -9364,         /* B1 = -0.571594 */
10271                  18880,         /* B0 = 0.576172 */
10272                  5,             /* Internal filter scaling */
10273                  159,           /* Minimum in-band energy threshold */
10274                  21,            /* 21/32 in-band to broad-band ratio */
10275                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10276         },
10277         {                       /* f1380 */
10278                 15247,          /* A1 = -0.930603 */
10279                  -32397,        /* A2 = 0.988708 */
10280                  -244,          /* B2 = -0.007451 */
10281                  0,             /* B1 = 0.000000 */
10282                  244,           /* B0 = 0.007451 */
10283                  14989,         /* A1 = -0.914886 */
10284                  -32627,        /* A2 = 0.995697 */
10285                  18961,         /* B2 = 0.578644 */
10286                  -8498,         /* B1 = -0.518707 */
10287                  18961,         /* B0 = 0.578644 */
10288                  15608,         /* A1 = -0.952667 */
10289                  -32628,        /* A2 = 0.995758 */
10290                  11145,         /* B2 = 0.340134 */
10291                  -5430,         /* B1 = -0.331467 */
10292                  11145,         /* B0 = 0.340134 */
10293                  5,             /* Internal filter scaling */
10294                  159,           /* Minimum in-band energy threshold */
10295                  21,            /* 21/32 in-band to broad-band ratio */
10296                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10297         },
10298         {                       /* f1400 */
10299                 14780,          /* A1 = -0.902130 */
10300                  -32393,        /* A2 = 0.988586 */
10301                  -396,          /* B2 = -0.012086 */
10302                  0,             /* B1 = 0.000000 */
10303                  396,           /* B0 = 0.012086 */
10304                  14510,         /* A1 = -0.885651 */
10305                  -32630,        /* A2 = 0.995819 */
10306                  6326,          /* B2 = 0.193069 */
10307                  -2747,         /* B1 = -0.167671 */
10308                  6326,          /* B0 = 0.193069 */
10309                  15154,         /* A1 = -0.924957 */
10310                  -32632,        /* A2 = 0.995850 */
10311                  23235,         /* B2 = 0.709076 */
10312                  -10983,        /* B1 = -0.670380 */
10313                  23235,         /* B0 = 0.709076 */
10314                  5,             /* Internal filter scaling */
10315                  159,           /* Minimum in-band energy threshold */
10316                  21,            /* 21/32 in-band to broad-band ratio */
10317                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10318         },
10319         {                       /* f1477 */
10320                 13005,          /* A1 = -0.793793 */
10321                  -32368,        /* A2 = 0.987823 */
10322                  -500,          /* B2 = -0.015265 */
10323                  0,             /* B1 = 0.000000 */
10324                  500,           /* B0 = 0.015265 */
10325                  12708,         /* A1 = -0.775665 */
10326                  -32615,        /* A2 = 0.995331 */
10327                  11420,         /* B2 = 0.348526 */
10328                  -4306,         /* B1 = -0.262833 */
10329                  11420,         /* B0 = 0.348526 */
10330                  13397,         /* A1 = -0.817688 */
10331                  -32615,        /* A2 = 0.995361 */
10332                  9454,          /* B2 = 0.288528 */
10333                  -3981,         /* B1 = -0.243027 */
10334                  9454,          /* B0 = 0.288528 */
10335                  5,             /* Internal filter scaling */
10336                  159,           /* Minimum in-band energy threshold */
10337                  21,            /* 21/32 in-band to broad-band ratio */
10338                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10339         },
10340         {                       /* f1600 */
10341                 10046,          /* A1 = -0.613190 */
10342                  -32331,        /* A2 = 0.986694 */
10343                  -455,          /* B2 = -0.013915 */
10344                  0,             /* B1 = 0.000000 */
10345                  455,           /* B0 = 0.013915 */
10346                  9694,          /* A1 = -0.591705 */
10347                  -32601,        /* A2 = 0.994934 */
10348                  6023,          /* B2 = 0.183815 */
10349                  -1708,         /* B1 = -0.104279 */
10350                  6023,          /* B0 = 0.183815 */
10351                  10478,         /* A1 = -0.639587 */
10352                  -32603,        /* A2 = 0.994965 */
10353                  22031,         /* B2 = 0.672333 */
10354                  -7342,         /* B1 = -0.448151 */
10355                  22031,         /* B0 = 0.672333 */
10356                  5,             /* Internal filter scaling */
10357                  159,           /* Minimum in-band energy threshold */
10358                  21,            /* 21/32 in-band to broad-band ratio */
10359                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10360         },
10361         {                       /* f1633_1638[] */
10362                 9181,           /* A1 = 0.560394 */
10363                  -32256,        /* A2 = -0.984375 */
10364                  -556,          /* B2 = -0.016975 */
10365                  0,             /* B1 = 0 */
10366                  556,           /* B0 = 0.016975 */
10367                  8757,          /* A1 = 0.534515 */
10368                  -32574,        /* A2 = -0.99408 */
10369                  8443,          /* B2 = 0.25769 */
10370                  -2135,         /* B1 = -0.130341 */
10371                  8443,          /* B0 = 0.25769 */
10372                  9691,          /* A1 = 0.591522 */
10373                  -32574,        /* A2 = -0.99411 */
10374                  15446,         /* B2 = 0.471375 */
10375                  -4809,         /* B1 = -0.293579 */
10376                  15446,         /* B0 = 0.471375 */
10377                  7,             /* Internal filter scaling */
10378                  159,           /* Minimum in-band energy threshold */
10379                  21,            /* 21/32 in-band to broad-band ratio */
10380                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10381         },
10382         {                       /* f1800 */
10383                 5076,           /* A1 = -0.309875 */
10384                  -32304,        /* A2 = 0.985840 */
10385                  -508,          /* B2 = -0.015503 */
10386                  0,             /* B1 = 0.000000 */
10387                  508,           /* B0 = 0.015503 */
10388                  4646,          /* A1 = -0.283600 */
10389                  -32605,        /* A2 = 0.995026 */
10390                  6742,          /* B2 = 0.205780 */
10391                  -878,          /* B1 = -0.053635 */
10392                  6742,          /* B0 = 0.205780 */
10393                  5552,          /* A1 = -0.338928 */
10394                  -32605,        /* A2 = 0.995056 */
10395                  23667,         /* B2 = 0.722260 */
10396                  -4297,         /* B1 = -0.262329 */
10397                  23667,         /* B0 = 0.722260 */
10398                  5,             /* Internal filter scaling */
10399                  159,           /* Minimum in-band energy threshold */
10400                  21,            /* 21/32 in-band to broad-band ratio */
10401                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10402         },
10403         {                       /* f1860 */
10404                 3569,           /* A1 = -0.217865 */
10405                  -32292,        /* A2 = 0.985504 */
10406                  -239,          /* B2 = -0.007322 */
10407                  0,             /* B1 = 0.000000 */
10408                  239,           /* B0 = 0.007322 */
10409                  3117,          /* A1 = -0.190277 */
10410                  -32603,        /* A2 = 0.994965 */
10411                  18658,         /* B2 = 0.569427 */
10412                  -1557,         /* B1 = -0.095032 */
10413                  18658,         /* B0 = 0.569427 */
10414                  4054,          /* A1 = -0.247437 */
10415                  -32603,        /* A2 = 0.994965 */
10416                  18886,         /* B2 = 0.576385 */
10417                  -2566,         /* B1 = -0.156647 */
10418                  18886,         /* B0 = 0.576385 */
10419                  5,             /* Internal filter scaling */
10420                  159,           /* Minimum in-band energy threshold */
10421                  21,            /* 21/32 in-band to broad-band ratio */
10422                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10423         },
10424 };
10425 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10426 {
10427         unsigned short cmd;
10428         int cnt, max;
10429
10430         if (jf->filter > 3) {
10431                 return -1;
10432         }
10433         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10434
10435                 return -1;
10436         if (!jf->enable) {
10437                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10438
10439                         return -1;
10440                 else
10441                         return 0;
10442         } else {
10443                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10444
10445                         return -1;
10446                 /* Select the filter (f0 - f3) to use. */
10447                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10448                         return -1;
10449         }
10450         if (jf->freq < 12 && jf->freq > 3) {
10451                 /* Select the frequency for the selected filter. */
10452                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10453                         return -1;
10454         } else if (jf->freq > 11) {
10455                 /* We need to load a programmable filter set for undefined */
10456                 /* frequencies.  So we will point the filter to a programmable set. */
10457                 /* Since there are only 4 filters and 4 programmable sets, we will */
10458                 /* just point the filter to the same number set and program it for the */
10459                 /* frequency we want. */
10460                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10461                         return -1;
10462                 if (j->ver.low != 0x12) {
10463                         cmd = 0x515B;
10464                         max = 19;
10465                 } else {
10466                         cmd = 0x515E;
10467                         max = 15;
10468                 }
10469                 if (ixj_WriteDSPCommand(cmd, j))
10470                         return -1;
10471                 for (cnt = 0; cnt < max; cnt++) {
10472                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10473                                 return -1;
10474                 }
10475         }
10476         j->filter_en[jf->filter] = jf->enable;
10477         return 0;
10478 }
10479
10480 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10481 {
10482         unsigned short cmd;
10483         int cnt, max;
10484         if (jfr->filter > 3) {
10485                 return -1;
10486         }
10487         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10488                 return -1;
10489
10490         if (!jfr->enable) {
10491                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10492                         return -1;
10493                 else
10494                         return 0;
10495         } else {
10496                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10497                         return -1;
10498                 /* Select the filter (f0 - f3) to use. */
10499                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10500                         return -1;
10501         }
10502         /* We need to load a programmable filter set for undefined */
10503         /* frequencies.  So we will point the filter to a programmable set. */
10504         /* Since there are only 4 filters and 4 programmable sets, we will */
10505         /* just point the filter to the same number set and program it for the */
10506         /* frequency we want. */
10507         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10508                 return -1;
10509         if (j->ver.low != 0x12) {
10510                 cmd = 0x515B;
10511                 max = 19;
10512         } else {
10513                 cmd = 0x515E;
10514                 max = 15;
10515         }
10516         if (ixj_WriteDSPCommand(cmd, j))
10517                 return -1;
10518         for (cnt = 0; cnt < max; cnt++) {
10519                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10520                         return -1;
10521         }
10522         j->filter_en[jfr->filter] = jfr->enable;
10523         return 0;
10524 }
10525
10526 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10527 {
10528         int freq0, freq1;
10529         unsigned short data;
10530         if (ti->freq0) {
10531                 freq0 = ti->freq0;
10532         } else {
10533                 freq0 = 0x7FFF;
10534         }
10535
10536         if (ti->freq1) {
10537                 freq1 = ti->freq1;
10538         } else {
10539                 freq1 = 0x7FFF;
10540         }
10541
10542         if(ti->tone_index > 12 && ti->tone_index < 28)
10543         {
10544                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10545                         return -1;
10546                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10547                         return -1;
10548                 data = freq0;
10549                 if (ixj_WriteDSPCommand(data, j))
10550                         return -1;
10551                 data = freq1;
10552                 if (ixj_WriteDSPCommand(data, j))
10553                         return -1;
10554         }
10555         return freq0;
10556 }
10557