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 static char ixj_c_rcsid[] = "$Id: ixj.c,v 4.7 2001/08/13 06:19:33 craigs Exp $";
  45 static char ixj_c_revision[] = "$Revision: 4.7 $";
  46
  47 /*
  48  * $Log: ixj.c,v $
  49  *
  50  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  51  * Audit some copy_*_user and minor cleanup.
  52  *
  53  * Revision 4.7  2001/08/13 06:19:33  craigs
  54  * Added additional changes from Alan Cox and John Anderson for
  55  * 2.2 to 2.4 cleanup and bounds checking
  56  *
  57  * Revision 4.6  2001/08/13 01:05:05  craigs
  58  * Really fixed PHONE_QUERY_CODEC problem this time
  59  *
  60  * Revision 4.5  2001/08/13 00:11:03  craigs
  61  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  62  *
  63  * Revision 4.4  2001/08/07 07:58:12  craigs
  64  * Changed back to three digit version numbers
  65  * Added tagbuild target to allow automatic and easy tagging of versions
  66  *
  67  * Revision 4.3  2001/08/07 07:24:47  craigs
  68  * Added ixj-ver.h to allow easy configuration management of driver
  69  * Added display of version number in /prox/ixj
  70  *
  71  * Revision 4.2  2001/08/06 07:07:19  craigs
  72  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  73  * behaviour of returning int rather than short *
  74  *
  75  * Revision 4.1  2001/08/05 00:17:37  craigs
  76  * More changes for correct PCMCIA installation
  77  * Start of changes for backward Linux compatibility
  78  *
  79  * Revision 4.0  2001/08/04 12:33:12  craigs
  80  * New version using GNU autoconf
  81  *
  82  * Revision 3.105  2001/07/20 23:14:32  eokerson
  83  * More work on CallerID generation when using ring cadences.
  84  *
  85  * Revision 3.104  2001/07/06 01:33:55  eokerson
  86  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  87  *
  88  * Revision 3.103  2001/07/05 19:20:16  eokerson
  89  * Updated HOWTO
  90  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  91  *
  92  * Revision 3.102  2001/07/03 23:51:21  eokerson
  93  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  94  *
  95  * Revision 3.101  2001/07/02 19:26:56  eokerson
  96  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  97  *
  98  * Revision 3.100  2001/07/02 19:18:27  eokerson
  99  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
 100  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
 101  * Fixed speaker mode on Internet LineJACK.
 102  *
 103  * Revision 3.99  2001/05/09 14:11:16  eokerson
 104  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 105  *
 106  * Revision 3.98  2001/05/08 19:55:33  eokerson
 107  * Fixed POTS hookstate detection while it is connected to PSTN port.
 108  *
 109  * Revision 3.97  2001/05/08 00:01:04  eokerson
 110  * Fixed kernel oops when sending caller ID data.
 111  *
 112  * Revision 3.96  2001/05/04 23:09:30  eokerson
 113  * Now uses one kernel timer for each card, instead of one for the entire driver.
 114  *
 115  * Revision 3.95  2001/04/25 22:06:47  eokerson
 116  * Fixed squawking at beginning of some G.723.1 calls.
 117  *
 118  * Revision 3.94  2001/04/03 23:42:00  eokerson
 119  * Added linear volume ioctls
 120  * Added raw filter load ioctl
 121  *
 122  * Revision 3.93  2001/02/27 01:00:06  eokerson
 123  * Fixed blocking in CallerID.
 124  * Reduced size of ixj structure for smaller driver footprint.
 125  *
 126  * Revision 3.92  2001/02/20 22:02:59  eokerson
 127  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 128  * Improved PSTN ring detection.
 129  * Fixed wink generation on POTS ports.
 130  *
 131  * Revision 3.91  2001/02/13 00:55:44  eokerson
 132  * Turn AEC back on after changing frame sizes.
 133  *
 134  * Revision 3.90  2001/02/12 16:42:00  eokerson
 135  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 136  *
 137  * Revision 3.89  2001/02/12 15:41:16  eokerson
 138  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 139  *
 140  * Revision 3.88  2001/02/05 23:25:42  eokerson
 141  * Fixed lockup bugs with deregister.
 142  *
 143  * Revision 3.87  2001/01/29 21:00:39  eokerson
 144  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 145  * Updated copyright date.
 146  *
 147  * Revision 3.86  2001/01/23 23:53:46  eokerson
 148  * Fixes to G.729 compatibility.
 149  *
 150  * Revision 3.85  2001/01/23 21:30:36  eokerson
 151  * Added verbage about cards supported.
 152  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 153  *
 154  * Revision 3.84  2001/01/22 23:32:10  eokerson
 155  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 156  *
 157  * Revision 3.83  2001/01/19 14:51:41  eokerson
 158  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 159  *
 160  * Revision 3.82  2001/01/19 00:34:49  eokerson
 161  * Added verbosity to write overlap errors.
 162  *
 163  * Revision 3.81  2001/01/18 23:56:54  eokerson
 164  * Fixed PSTN line test functions.
 165  *
 166  * Revision 3.80  2001/01/18 22:29:27  eokerson
 167  * Updated AEC/AGC values for different cards.
 168  *
 169  * Revision 3.79  2001/01/17 02:58:54  eokerson
 170  * Fixed AEC reset after Caller ID.
 171  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 172  *
 173  * Revision 3.78  2001/01/16 19:43:09  eokerson
 174  * Added support for Linux 2.4.x kernels.
 175  *
 176  * Revision 3.77  2001/01/09 04:00:52  eokerson
 177  * Linetest will now test the line, even if it has previously succeded.
 178  *
 179  * Revision 3.76  2001/01/08 19:27:00  eokerson
 180  * Fixed problem with standard cable on Internet PhoneCARD.
 181  *
 182  * Revision 3.75  2000/12/22 16:52:14  eokerson
 183  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 184  *
 185  * Revision 3.74  2000/12/08 22:41:50  eokerson
 186  * Added capability for G729B.
 187  *
 188  * Revision 3.73  2000/12/07 23:35:16  eokerson
 189  * Added capability to have different ring pattern before CallerID data.
 190  * Added hookstate checks in CallerID routines to stop FSK.
 191  *
 192  * Revision 3.72  2000/12/06 19:31:31  eokerson
 193  * Modified signal behavior to only send one signal per event.
 194  *
 195  * Revision 3.71  2000/12/06 03:23:08  eokerson
 196  * Fixed CallerID on Call Waiting.
 197  *
 198  * Revision 3.70  2000/12/04 21:29:37  eokerson
 199  * Added checking to Smart Cable gain functions.
 200  *
 201  * Revision 3.69  2000/12/04 21:05:20  eokerson
 202  * Changed ixjdebug levels.
 203  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 204  *
 205  * Revision 3.68  2000/12/04 00:17:21  craigs
 206  * Changed mixer voice gain to +6dB rather than 0dB
 207  *
 208  * Revision 3.67  2000/11/30 21:25:51  eokerson
 209  * Fixed write signal errors.
 210  *
 211  * Revision 3.66  2000/11/29 22:42:44  eokerson
 212  * Fixed PSTN ring detect problems.
 213  *
 214  * Revision 3.65  2000/11/29 07:31:55  craigs
 215  * Added new 425Hz filter co-efficients
 216  * Added card-specific DTMF prescaler initialisation
 217  *
 218  * Revision 3.64  2000/11/28 14:03:32  craigs
 219  * Changed certain mixer initialisations to be 0dB rather than 12dB
 220  * Added additional information to /proc/ixj
 221  *
 222  * Revision 3.63  2000/11/28 11:38:41  craigs
 223  * Added display of AEC modes in AUTO and AGC mode
 224  *
 225  * Revision 3.62  2000/11/28 04:05:44  eokerson
 226  * Improved PSTN ring detection routine.
 227  *
 228  * Revision 3.61  2000/11/27 21:53:12  eokerson
 229  * Fixed flash detection.
 230  *
 231  * Revision 3.60  2000/11/27 15:57:29  eokerson
 232  * More work on G.729 load routines.
 233  *
 234  * Revision 3.59  2000/11/25 21:55:12  eokerson
 235  * Fixed errors in G.729 load routine.
 236  *
 237  * Revision 3.58  2000/11/25 04:08:29  eokerson
 238  * Added board locks around G.729 and TS85 load routines.
 239  *
 240  * Revision 3.57  2000/11/24 05:35:17  craigs
 241  * Added ability to retrieve mixer values on LineJACK
 242  * Added complete initialisation of all mixer values at startup
 243  * Fixed spelling mistake
 244  *
 245  * Revision 3.56  2000/11/23 02:52:11  robertj
 246  * Added cvs change log keyword.
 247  * Fixed bug in capabilities list when using G.729 module.
 248  *
 249  */
 250
 251 #include "ixj-ver.h"
 252
 253 #define PERFMON_STATS
 254 #define IXJDEBUG 0
 255 #define MAXRINGS 5
 256
 257 #include <linux/module.h>
 258
 259 #include <linux/init.h>
 260 #include <linux/sched.h>
 261 #include <linux/kernel.h>       /* printk() */
 262 #include <linux/fs.h>           /* everything... */
 263 #include <linux/errno.h>        /* error codes */
 264 #include <linux/slab.h>
 265 #include <linux/mm.h>
 266 #include <linux/ioport.h>
 267 #include <linux/interrupt.h>
 268 #include <linux/proc_fs.h>
 269 #include <linux/poll.h>
 270 #include <linux/timer.h>
 271 #include <linux/delay.h>
 272 #include <linux/pci.h>
 273
 274 #include <asm/io.h>
 275 #include <asm/uaccess.h>
 276
 277 #include <linux/isapnp.h>
 278
 279 #include "ixj.h"
 280
 281 #define TYPE(inode) (iminor(inode) >> 4)
 282 #define NUM(inode) (iminor(inode) & 0xf)
 283
 284 static int ixjdebug;
 285 static int hertz = HZ;
 286 static int samplerate = 100;
 287
 288 MODULE_PARM(ixjdebug, "i");
 289
 290 /************************************************************************
 291 *
 292 * ixjdebug meanings are now bit mapped instead of level based
 293 * Values can be or'ed together to turn on multiple messages
 294 *
 295 * bit  0 (0x0001) = any failure
 296 * bit  1 (0x0002) = general messages
 297 * bit  2 (0x0004) = POTS ringing related
 298 * bit  3 (0x0008) = PSTN events
 299 * bit  4 (0x0010) = PSTN Cadence state details
 300 * bit  5 (0x0020) = Tone detection triggers
 301 * bit  6 (0x0040) = Tone detection cadence details
 302 * bit  7 (0x0080) = ioctl tracking
 303 * bit  8 (0x0100) = signal tracking
 304 * bit  9 (0x0200) = CallerID generation details
 305 *
 306 ************************************************************************/
 307
 308 #ifdef IXJ_DYN_ALLOC
 309
 310 static IXJ *ixj[IXJMAX];
 311 #define get_ixj(b)      ixj[(b)]
 312
 313 /*
 314  *      Allocate a free IXJ device
 315  */
 316
 317 static IXJ *ixj_alloc()
 318 {
 319         for(cnt=0; cnt<IXJMAX; cnt++)
 320         {
 321                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 322                 {
 323                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 324                         if (j == NULL)
 325                                 return NULL;
 326                         ixj[cnt] = j;
 327                         return j;
 328                 }
 329         }
 330         return NULL;
 331 }
 332
 333 static void ixj_fsk_free(IXJ *j)
 334 {
 335         if(j->fskdata != NULL) {
 336                 kfree(j->fskdata);
 337                 j->fskdata = NULL;
 338         }
 339 }
 340
 341 static void ixj_fsk_alloc(IXJ *j)
 342 {
 343         if(!j->fskdata) {
 344                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 345                 if (!j->fskdata) {
 346                         if(ixjdebug & 0x0200) {
 347                                 printk("IXJ phone%d - allocate failed\n", j->board);
 348                         }
 349                         return;
 350                 } else {
 351                         j->fsksize = 8000;
 352                         if(ixjdebug & 0x0200) {
 353                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 354                         }
 355                 }
 356         }
 357 }
 358
 359 #else
 360
 361 static IXJ ixj[IXJMAX];
 362 #define get_ixj(b)      (&ixj[(b)])
 363
 364 /*
 365  *      Allocate a free IXJ device
 366  */
 367
 368 static IXJ *ixj_alloc(void)
 369 {
 370         int cnt;
 371         for(cnt=0; cnt<IXJMAX; cnt++) {
 372                 if(!ixj[cnt].DSPbase)
 373                         return &ixj[cnt];
 374         }
 375         return NULL;
 376 }
 377
 378 static inline void ixj_fsk_free(IXJ *j) {;}
 379
 380 static inline void ixj_fsk_alloc(IXJ *j)
 381 {
 382         j->fsksize = 8000;
 383 }
 384
 385 #endif
 386
 387 #ifdef PERFMON_STATS
 388 #define ixj_perfmon(x)  ((x)++)
 389 #else
 390 #define ixj_perfmon(x)  do { } while(0)
 391 #endif
 392
 393 static int ixj_convert_loaded;
 394
 395 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 396
 397 /************************************************************************
 398 *
 399 * These are function definitions to allow external modules to register
 400 * enhanced functionality call backs.
 401 *
 402 ************************************************************************/
 403
 404 static int Stub(IXJ * J, unsigned long arg)
 405 {
 406         return 0;
 407 }
 408
 409 static IXJ_REGFUNC ixj_DownloadG729 = &Stub;
 410 static IXJ_REGFUNC ixj_DownloadTS85 = &Stub;
 411 static IXJ_REGFUNC ixj_PreRead = &Stub;
 412 static IXJ_REGFUNC ixj_PostRead = &Stub;
 413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 415 static IXJ_REGFUNC ixj_PreIoctl = &Stub;
 416 static IXJ_REGFUNC ixj_PostIoctl = &Stub;
 417
 418 static void ixj_read_frame(IXJ *j);
 419 static void ixj_write_frame(IXJ *j);
 420 static void ixj_init_timer(IXJ *j);
 421 static void ixj_add_timer(IXJ * j);
 422 static void ixj_timeout(unsigned long ptr);
 423 static int read_filters(IXJ *j);
 424 static int LineMonitor(IXJ *j);
 425 static int ixj_fasync(int fd, struct file *, int mode);
 426 static int ixj_set_port(IXJ *j, int arg);
 427 static int ixj_set_pots(IXJ *j, int arg);
 428 static int ixj_hookstate(IXJ *j);
 429 static int ixj_record_start(IXJ *j);
 430 static void ixj_record_stop(IXJ *j);
 431 static void set_rec_volume(IXJ *j, int volume);
 432 static int get_rec_volume(IXJ *j);
 433 static int set_rec_codec(IXJ *j, int rate);
 434 static void ixj_vad(IXJ *j, int arg);
 435 static int ixj_play_start(IXJ *j);
 436 static void ixj_play_stop(IXJ *j);
 437 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 438 static int ixj_set_tone_off(unsigned short, IXJ *j);
 439 static int ixj_play_tone(IXJ *j, char tone);
 440 static void ixj_aec_start(IXJ *j, int level);
 441 static int idle(IXJ *j);
 442 static void ixj_ring_on(IXJ *j);
 443 static void ixj_ring_off(IXJ *j);
 444 static void aec_stop(IXJ *j);
 445 static void ixj_ringback(IXJ *j);
 446 static void ixj_busytone(IXJ *j);
 447 static void ixj_dialtone(IXJ *j);
 448 static void ixj_cpt_stop(IXJ *j);
 449 static char daa_int_read(IXJ *j);
 450 static char daa_CR_read(IXJ *j, int cr);
 451 static int daa_set_mode(IXJ *j, int mode);
 452 static int ixj_linetest(IXJ *j);
 453 static int ixj_daa_write(IXJ *j);
 454 static int ixj_daa_cid_read(IXJ *j);
 455 static void DAA_Coeff_US(IXJ *j);
 456 static void DAA_Coeff_UK(IXJ *j);
 457 static void DAA_Coeff_France(IXJ *j);
 458 static void DAA_Coeff_Germany(IXJ *j);
 459 static void DAA_Coeff_Australia(IXJ *j);
 460 static void DAA_Coeff_Japan(IXJ *j);
 461 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 462 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 463 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 464 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 465 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 466 /* Serial Control Interface funtions */
 467 static int SCI_Control(IXJ *j, int control);
 468 static int SCI_Prepare(IXJ *j);
 469 static int SCI_WaitHighSCI(IXJ *j);
 470 static int SCI_WaitLowSCI(IXJ *j);
 471 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 472 static int ixj_PCcontrol_wait(IXJ *j);
 473 static void ixj_pre_cid(IXJ *j);
 474 static void ixj_write_cid(IXJ *j);
 475 static void ixj_write_cid_bit(IXJ *j, int bit);
 476 static int set_base_frame(IXJ *j, int size);
 477 static int set_play_codec(IXJ *j, int rate);
 478 static void set_rec_depth(IXJ *j, int depth);
 479 static int ixj_mixer(long val, IXJ *j);
 480
 481 /************************************************************************
 482 CT8020/CT8021 Host Programmers Model
 483 Host address    Function                                        Access
 484 DSPbase +
 485 0-1             Aux Software Status Register (reserved)         Read Only
 486 2-3             Software Status Register                        Read Only
 487 4-5             Aux Software Control Register (reserved)        Read Write
 488 6-7             Software Control Register                       Read Write
 489 8-9             Hardware Status Register                        Read Only
 490 A-B             Hardware Control Register                       Read Write
 491 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 492 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 493 ************************************************************************/
 494
 495 static inline void ixj_read_HSR(IXJ *j)
 496 {
 497         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 498         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 499 }
 500
 501 static inline int IsControlReady(IXJ *j)
 502 {
 503         ixj_read_HSR(j);
 504         return j->hsr.bits.controlrdy ? 1 : 0;
 505 }
 506
 507 static inline int IsPCControlReady(IXJ *j)
 508 {
 509         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 510         return j->pccr1.bits.crr ? 1 : 0;
 511 }
 512
 513 static inline int IsStatusReady(IXJ *j)
 514 {
 515         ixj_read_HSR(j);
 516         return j->hsr.bits.statusrdy ? 1 : 0;
 517 }
 518
 519 static inline int IsRxReady(IXJ *j)
 520 {
 521         ixj_read_HSR(j);
 522         ixj_perfmon(j->rxreadycheck);
 523         return j->hsr.bits.rxrdy ? 1 : 0;
 524 }
 525
 526 static inline int IsTxReady(IXJ *j)
 527 {
 528         ixj_read_HSR(j);
 529         ixj_perfmon(j->txreadycheck);
 530         return j->hsr.bits.txrdy ? 1 : 0;
 531 }
 532
 533 static inline void set_play_volume(IXJ *j, int volume)
 534 {
 535         if (ixjdebug & 0x0002)
 536                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 537         ixj_WriteDSPCommand(0xCF02, j);
 538         ixj_WriteDSPCommand(volume, j);
 539 }
 540
 541 static int set_play_volume_linear(IXJ *j, int volume)
 542 {
 543         int newvolume, dspplaymax;
 544
 545         if (ixjdebug & 0x0002)
 546                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 547         if(volume > 100 || volume < 0) {
 548                 return -1;
 549         }
 550
 551         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 552         switch (j->cardtype) {
 553         case QTI_PHONEJACK:
 554                 dspplaymax = 0x380;
 555                 break;
 556         case QTI_LINEJACK:
 557                 if(j->port == PORT_PSTN) {
 558                         dspplaymax = 0x48;
 559                 } else {
 560                         dspplaymax = 0x100;
 561                 }
 562                 break;
 563         case QTI_PHONEJACK_LITE:
 564                 dspplaymax = 0x380;
 565                 break;
 566         case QTI_PHONEJACK_PCI:
 567                 dspplaymax = 0x6C;
 568                 break;
 569         case QTI_PHONECARD:
 570                 dspplaymax = 0x50;
 571                 break;
 572         default:
 573                 return -1;
 574         }
 575         newvolume = (dspplaymax * volume) / 100;
 576         set_play_volume(j, newvolume);
 577         return 0;
 578 }
 579
 580 static inline void set_play_depth(IXJ *j, int depth)
 581 {
 582         if (depth > 60)
 583                 depth = 60;
 584         if (depth < 0)
 585                 depth = 0;
 586         ixj_WriteDSPCommand(0x5280 + depth, j);
 587 }
 588
 589 static inline int get_play_volume(IXJ *j)
 590 {
 591         ixj_WriteDSPCommand(0xCF00, j);
 592         return j->ssr.high << 8 | j->ssr.low;
 593 }
 594
 595 static int get_play_volume_linear(IXJ *j)
 596 {
 597         int volume, newvolume, dspplaymax;
 598
 599         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 600         switch (j->cardtype) {
 601         case QTI_PHONEJACK:
 602                 dspplaymax = 0x380;
 603                 break;
 604         case QTI_LINEJACK:
 605                 if(j->port == PORT_PSTN) {
 606                         dspplaymax = 0x48;
 607                 } else {
 608                         dspplaymax = 0x100;
 609                 }
 610                 break;
 611         case QTI_PHONEJACK_LITE:
 612                 dspplaymax = 0x380;
 613                 break;
 614         case QTI_PHONEJACK_PCI:
 615                 dspplaymax = 0x6C;
 616                 break;
 617         case QTI_PHONECARD:
 618                 dspplaymax = 100;
 619                 break;
 620         default:
 621                 return -1;
 622         }
 623         volume = get_play_volume(j);
 624         newvolume = (volume * 100) / dspplaymax;
 625         if(newvolume > 100)
 626                 newvolume = 100;
 627         return newvolume;
 628 }
 629
 630 static inline BYTE SLIC_GetState(IXJ *j)
 631 {
 632         if (j->cardtype == QTI_PHONECARD) {
 633                 j->pccr1.byte = 0;
 634                 j->psccr.bits.dev = 3;
 635                 j->psccr.bits.rw = 1;
 636                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 637                 ixj_PCcontrol_wait(j);
 638                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 639                 ixj_PCcontrol_wait(j);
 640                 if (j->pslic.bits.powerdown)
 641                         return PLD_SLIC_STATE_OC;
 642                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 643                         return PLD_SLIC_STATE_ACTIVE;
 644                 else
 645                         return PLD_SLIC_STATE_RINGING;
 646         } else {
 647                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 648         }
 649         return j->pld_slicr.bits.state;
 650 }
 651
 652 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
 653 {
 654         BOOL fRetVal = FALSE;
 655
 656         if (j->cardtype == QTI_PHONECARD) {
 657                 if (j->flags.pcmciasct) {
 658                         switch (byState) {
 659                         case PLD_SLIC_STATE_TIPOPEN:
 660                         case PLD_SLIC_STATE_OC:
 661                                 j->pslic.bits.powerdown = 1;
 662                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 663                                 fRetVal = TRUE;
 664                                 break;
 665                         case PLD_SLIC_STATE_RINGING:
 666                                 if (j->readers || j->writers) {
 667                                         j->pslic.bits.powerdown = 0;
 668                                         j->pslic.bits.ring0 = 1;
 669                                         j->pslic.bits.ring1 = 0;
 670                                         fRetVal = TRUE;
 671                                 }
 672                                 break;
 673                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 674
 675                         case PLD_SLIC_STATE_STANDBY:
 676                         case PLD_SLIC_STATE_ACTIVE:
 677                                 if (j->readers || j->writers) {
 678                                         j->pslic.bits.powerdown = 0;
 679                                 } else {
 680                                         j->pslic.bits.powerdown = 1;
 681                                 }
 682                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 683                                 fRetVal = TRUE;
 684                                 break;
 685                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 686
 687                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 688
 689                         default:
 690                                 fRetVal = FALSE;
 691                                 break;
 692                         }
 693                         j->psccr.bits.dev = 3;
 694                         j->psccr.bits.rw = 0;
 695                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 696                         ixj_PCcontrol_wait(j);
 697                 }
 698         } else {
 699                 /* Set the C1, C2, C3 & B2EN signals. */
 700                 switch (byState) {
 701                 case PLD_SLIC_STATE_OC:
 702                         j->pld_slicw.bits.c1 = 0;
 703                         j->pld_slicw.bits.c2 = 0;
 704                         j->pld_slicw.bits.c3 = 0;
 705                         j->pld_slicw.bits.b2en = 0;
 706                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 707                         fRetVal = TRUE;
 708                         break;
 709                 case PLD_SLIC_STATE_RINGING:
 710                         j->pld_slicw.bits.c1 = 1;
 711                         j->pld_slicw.bits.c2 = 0;
 712                         j->pld_slicw.bits.c3 = 0;
 713                         j->pld_slicw.bits.b2en = 1;
 714                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 715                         fRetVal = TRUE;
 716                         break;
 717                 case PLD_SLIC_STATE_ACTIVE:
 718                         j->pld_slicw.bits.c1 = 0;
 719                         j->pld_slicw.bits.c2 = 1;
 720                         j->pld_slicw.bits.c3 = 0;
 721                         j->pld_slicw.bits.b2en = 0;
 722                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 723                         fRetVal = TRUE;
 724                         break;
 725                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 726
 727                         j->pld_slicw.bits.c1 = 1;
 728                         j->pld_slicw.bits.c2 = 1;
 729                         j->pld_slicw.bits.c3 = 0;
 730                         j->pld_slicw.bits.b2en = 0;
 731                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 732                         fRetVal = TRUE;
 733                         break;
 734                 case PLD_SLIC_STATE_TIPOPEN:
 735                         j->pld_slicw.bits.c1 = 0;
 736                         j->pld_slicw.bits.c2 = 0;
 737                         j->pld_slicw.bits.c3 = 1;
 738                         j->pld_slicw.bits.b2en = 0;
 739                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 740                         fRetVal = TRUE;
 741                         break;
 742                 case PLD_SLIC_STATE_STANDBY:
 743                         j->pld_slicw.bits.c1 = 1;
 744                         j->pld_slicw.bits.c2 = 0;
 745                         j->pld_slicw.bits.c3 = 1;
 746                         j->pld_slicw.bits.b2en = 1;
 747                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 748                         fRetVal = TRUE;
 749                         break;
 750                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 751
 752                         j->pld_slicw.bits.c1 = 0;
 753                         j->pld_slicw.bits.c2 = 1;
 754                         j->pld_slicw.bits.c3 = 1;
 755                         j->pld_slicw.bits.b2en = 0;
 756                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 757                         fRetVal = TRUE;
 758                         break;
 759                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 760
 761                         j->pld_slicw.bits.c1 = 1;
 762                         j->pld_slicw.bits.c2 = 1;
 763                         j->pld_slicw.bits.c3 = 1;
 764                         j->pld_slicw.bits.b2en = 0;
 765                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 766                         fRetVal = TRUE;
 767                         break;
 768                 default:
 769                         fRetVal = FALSE;
 770                         break;
 771                 }
 772         }
 773
 774         return fRetVal;
 775 }
 776
 777 static int ixj_wink(IXJ *j)
 778 {
 779         BYTE slicnow;
 780
 781         slicnow = SLIC_GetState(j);
 782
 783         j->pots_winkstart = jiffies;
 784         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 785
 786         while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
 787                 set_current_state(TASK_INTERRUPTIBLE);
 788                 schedule_timeout(1);
 789         }
 790
 791         SLIC_SetState(slicnow, j);
 792         return 0;
 793 }
 794
 795 static int ixj_register(int index, IXJ_REGFUNC regfunc)
 796 {
 797         int cnt;
 798         int retval = 0;
 799         switch (index) {
 800         case G729LOADER:
 801                 ixj_DownloadG729 = regfunc;
 802                 for (cnt = 0; cnt < IXJMAX; cnt++) {
 803                         IXJ *j = get_ixj(cnt);
 804                         while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
 805                                 set_current_state(TASK_INTERRUPTIBLE);
 806                                 schedule_timeout(1);
 807                         }
 808                         ixj_DownloadG729(j, 0L);
 809                         clear_bit(cnt, &j->busyflags);
 810                 }
 811                 break;
 812         case TS85LOADER:
 813                 ixj_DownloadTS85 = regfunc;
 814                 for (cnt = 0; cnt < IXJMAX; cnt++) {
 815                         IXJ *j = get_ixj(cnt);
 816                         while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
 817                                 set_current_state(TASK_INTERRUPTIBLE);
 818                                 schedule_timeout(1);
 819                         }
 820                         ixj_DownloadTS85(j, 0L);
 821                         clear_bit(cnt, &j->busyflags);
 822                 }
 823                 break;
 824         case PRE_READ:
 825                 ixj_PreRead = regfunc;
 826                 break;
 827         case POST_READ:
 828                 ixj_PostRead = regfunc;
 829                 break;
 830         case PRE_WRITE:
 831                 ixj_PreWrite = regfunc;
 832                 break;
 833         case POST_WRITE:
 834                 ixj_PostWrite = regfunc;
 835                 break;
 836         case PRE_IOCTL:
 837                 ixj_PreIoctl = regfunc;
 838                 break;
 839         case POST_IOCTL:
 840                 ixj_PostIoctl = regfunc;
 841                 break;
 842         default:
 843                 retval = 1;
 844         }
 845         return retval;
 846 }
 847
 848 EXPORT_SYMBOL(ixj_register);
 849
 850 static int ixj_unregister(int index)
 851 {
 852         int retval = 0;
 853         switch (index) {
 854         case G729LOADER:
 855                 ixj_DownloadG729 = &Stub;
 856                 break;
 857         case TS85LOADER:
 858                 ixj_DownloadTS85 = &Stub;
 859                 break;
 860         case PRE_READ:
 861                 ixj_PreRead = &Stub;
 862                 break;
 863         case POST_READ:
 864                 ixj_PostRead = &Stub;
 865                 break;
 866         case PRE_WRITE:
 867                 ixj_PreWrite = &Stub;
 868                 break;
 869         case POST_WRITE:
 870                 ixj_PostWrite = &Stub;
 871                 break;
 872         case PRE_IOCTL:
 873                 ixj_PreIoctl = &Stub;
 874                 break;
 875         case POST_IOCTL:
 876                 ixj_PostIoctl = &Stub;
 877                 break;
 878         default:
 879                 retval = 1;
 880         }
 881         return retval;
 882 }
 883
 884 EXPORT_SYMBOL(ixj_unregister);
 885
 886 static void ixj_init_timer(IXJ *j)
 887 {
 888         init_timer(&j->timer);
 889         j->timer.function = ixj_timeout;
 890         j->timer.data = (unsigned long)j;
 891 }
 892
 893 static void ixj_add_timer(IXJ *j)
 894 {
 895         j->timer.expires = jiffies + (hertz / samplerate);
 896         add_timer(&j->timer);
 897 }
 898
 899 static void ixj_tone_timeout(IXJ *j)
 900 {
 901         IXJ_TONE ti;
 902
 903         j->tone_state++;
 904         if (j->tone_state == 3) {
 905                 j->tone_state = 0;
 906                 if (j->cadence_t) {
 907                         j->tone_cadence_state++;
 908                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 909                                 switch (j->cadence_t->termination) {
 910                                 case PLAY_ONCE:
 911                                         ixj_cpt_stop(j);
 912                                         break;
 913                                 case REPEAT_LAST_ELEMENT:
 914                                         j->tone_cadence_state--;
 915                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 916                                         break;
 917                                 case REPEAT_ALL:
 918                                         j->tone_cadence_state = 0;
 919                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 920                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 921                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 922                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 923                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 924                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 925                                                 ixj_init_tone(j, &ti);
 926                                         }
 927                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 928                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 929                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 930                                         break;
 931                                 }
 932                         } else {
 933                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 934                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 935                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 936                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 937                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 938                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 939                                         ixj_init_tone(j, &ti);
 940                                 }
 941                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 942                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 943                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 944                         }
 945                 }
 946         }
 947 }
 948
 949 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 950 {
 951         if(j->ixj_signals[event]) {
 952                 if(ixjdebug & 0x0100)
 953                         printk("Sending signal for event %d\n", event);
 954                         /* Send apps notice of change */
 955                 /* see config.h for macro definition */
 956                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 957         }
 958 }
 959
 960 static void ixj_pstn_state(IXJ *j)
 961 {
 962         int var;
 963         union XOPXR0 XR0, daaint;
 964
 965         var = 10;
 966
 967         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 968         daaint.reg = 0;
 969         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 970
 971         j->pld_scrr.byte = inb_p(j->XILINXbase);
 972         if (j->pld_scrr.bits.daaflag) {
 973                 daa_int_read(j);
 974                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 975                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 976                                 daaint.bitreg.RING = 1;
 977                                 if(ixjdebug & 0x0008) {
 978                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 979                                 }
 980                         } else {
 981                                 daa_set_mode(j, SOP_PU_RESET);
 982                         }
 983                 }
 984                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 985                         daaint.bitreg.Caller_ID = 1;
 986                         j->pstn_cid_intr = 1;
 987                         j->pstn_cid_received = jiffies;
 988                         if(ixjdebug & 0x0008) {
 989                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 990                         }
 991                 }
 992                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 993                         daaint.bitreg.Cadence = 1;
 994                         if(ixjdebug & 0x0008) {
 995                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 996                         }
 997                 }
 998                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 999                         daaint.bitreg.VDD_OK = 1;
1000                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
1001                 }
1002         }
1003         daa_CR_read(j, 1);
1004         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)) {
1005                 daaint.bitreg.RMR = 1;
1006                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
1007                 if(ixjdebug & 0x0008) {
1008                         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);
1009                 }
1010                 j->pstn_prev_rmr = j->pstn_last_rmr;
1011                 j->pstn_last_rmr = jiffies;
1012         }
1013         switch(j->daa_mode) {
1014                 case SOP_PU_SLEEP:
1015                         if (daaint.bitreg.RING) {
1016                                 if (!j->flags.pstn_ringing) {
1017                                         if (j->daa_mode != SOP_PU_RINGING) {
1018                                                 j->pstn_ring_int = jiffies;
1019                                                 daa_set_mode(j, SOP_PU_RINGING);
1020                                         }
1021                                 }
1022                         }
1023                         break;
1024                 case SOP_PU_RINGING:
1025                         if (daaint.bitreg.RMR) {
1026                                 if (ixjdebug & 0x0008) {
1027                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1028                                 }
1029                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
1030                                         j->flags.pstn_rmr = 1;
1031                                         j->pstn_ring_start = jiffies;
1032                                         j->pstn_ring_stop = 0;
1033                                         j->ex.bits.pstn_ring = 0;
1034                                         if (j->cadence_f[4].state == 0) {
1035                                                 j->cadence_f[4].state = 1;
1036                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
1037                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
1038                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
1039                                         } else if (j->cadence_f[4].state == 2) {
1040                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
1041                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
1042                                                         if (j->cadence_f[4].on2) {
1043                                                                 j->cadence_f[4].state = 3;
1044                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
1045                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
1046                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
1047                                                         } else {
1048                                                                 j->cadence_f[4].state = 7;
1049                                                         }
1050                                                 } else {
1051                                                         if (ixjdebug & 0x0008) {
1052                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1053                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1054                                                                                 j->cadence_f[4].off1);
1055                                                         }
1056                                                         j->cadence_f[4].state = 0;
1057                                                 }
1058                                         } else if (j->cadence_f[4].state == 4) {
1059                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
1060                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
1061                                                         if (j->cadence_f[4].on3) {
1062                                                                 j->cadence_f[4].state = 5;
1063                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
1064                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
1065                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
1066                                                         } else {
1067                                                                 j->cadence_f[4].state = 7;
1068                                                         }
1069                                                 } else {
1070                                                         if (ixjdebug & 0x0008) {
1071                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1072                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1073                                                                                 j->cadence_f[4].off2);
1074                                                         }
1075                                                         j->cadence_f[4].state = 0;
1076                                                 }
1077                                         } else if (j->cadence_f[4].state == 6) {
1078                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
1079                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
1080                                                         j->cadence_f[4].state = 7;
1081                                                 } else {
1082                                                         if (ixjdebug & 0x0008) {
1083                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1084                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1085                                                                                 j->cadence_f[4].off3);
1086                                                         }
1087                                                         j->cadence_f[4].state = 0;
1088                                                 }
1089                                         } else {
1090                                                 j->cadence_f[4].state = 0;
1091                                         }
1092                                 } else {                                /* Falling edge of RMR */
1093                                         j->pstn_ring_start = 0;
1094                                         j->pstn_ring_stop = jiffies;
1095                                         if (j->cadence_f[4].state == 1) {
1096                                                 if(!j->cadence_f[4].on1) {
1097                                                         j->cadence_f[4].state = 7;
1098                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1099                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1100                                                         if (j->cadence_f[4].off1) {
1101                                                                 j->cadence_f[4].state = 2;
1102                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1103                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1104                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1105                                                         } else {
1106                                                                 j->cadence_f[4].state = 7;
1107                                                         }
1108                                                 } else {
1109                                                         if (ixjdebug & 0x0008) {
1110                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1111                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1112                                                                                 j->cadence_f[4].on1);
1113                                                         }
1114                                                         j->cadence_f[4].state = 0;
1115                                                 }
1116                                         } else if (j->cadence_f[4].state == 3) {
1117                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1118                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1119                                                         if (j->cadence_f[4].off2) {
1120                                                                 j->cadence_f[4].state = 4;
1121                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1122                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1123                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1124                                                         } else {
1125                                                                 j->cadence_f[4].state = 7;
1126                                                         }
1127                                                 } else {
1128                                                         if (ixjdebug & 0x0008) {
1129                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1130                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1131                                                                                 j->cadence_f[4].on2);
1132                                                         }
1133                                                         j->cadence_f[4].state = 0;
1134                                                 }
1135                                         } else if (j->cadence_f[4].state == 5) {
1136                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1137                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1138                                                         if (j->cadence_f[4].off3) {
1139                                                                 j->cadence_f[4].state = 6;
1140                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1141                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1142                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1143                                                         } else {
1144                                                                 j->cadence_f[4].state = 7;
1145                                                         }
1146                                                 } else {
1147                                                         j->cadence_f[4].state = 0;
1148                                                 }
1149                                         } else {
1150                                                 if (ixjdebug & 0x0008) {
1151                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1152                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1153                                                                         j->cadence_f[4].on3);
1154                                                 }
1155                                                 j->cadence_f[4].state = 0;
1156                                         }
1157                                 }
1158                                 if (ixjdebug & 0x0010) {
1159                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1160                                 }
1161                                 if (ixjdebug & 0x0010) {
1162                                         switch(j->cadence_f[4].state) {
1163                                                 case 1:
1164                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1165                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1166                                                         break;
1167                                                 case 2:
1168                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1169                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1170                                                         break;
1171                                                 case 3:
1172                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1173                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1174                                                         break;
1175                                                 case 4:
1176                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1177                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1178                                                         break;
1179                                                 case 5:
1180                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1181                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1182                                                         break;
1183                                                 case 6:
1184                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1185                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1186                                                         break;
1187                                         }
1188                                 }
1189                         }
1190                         if (j->cadence_f[4].state == 7) {
1191                                 j->cadence_f[4].state = 0;
1192                                 j->pstn_ring_stop = jiffies;
1193                                 j->ex.bits.pstn_ring = 1;
1194                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1195                                 if(ixjdebug & 0x0008) {
1196                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1197                                 }
1198                         }
1199                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1200                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1201                                 if(ixjdebug & 0x0008) {
1202                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1203                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1204                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1205                                 }
1206                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1207                                 daa_set_mode(j, SOP_PU_SLEEP);
1208                         }
1209                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1210                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1211                                 ixj_daa_cid_read(j);
1212                                 j->ex.bits.caller_id = 1;
1213                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1214                                 j->pstn_cid_intr = 0;
1215                         }
1216                         if (daaint.bitreg.Cadence) {
1217                                 if(ixjdebug & 0x0008) {
1218                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1219                                 }
1220                                 daa_set_mode(j, SOP_PU_SLEEP);
1221                                 j->ex.bits.pstn_ring = 0;
1222                         }
1223                         break;
1224                 case SOP_PU_CONVERSATION:
1225                         if (daaint.bitreg.VDD_OK) {
1226                                 if(!daaint.bitreg.SI_0) {
1227                                         if (!j->pstn_winkstart) {
1228                                                 if(ixjdebug & 0x0008) {
1229                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1230                                                 }
1231                                                 j->pstn_winkstart = jiffies;
1232                                         }
1233                                 } else {
1234                                         if (j->pstn_winkstart) {
1235                                                 if(ixjdebug & 0x0008) {
1236                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1237                                                 }
1238                                                 j->pstn_winkstart = 0;
1239                                         }
1240                                 }
1241                         }
1242                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1243                                 if(ixjdebug & 0x0008) {
1244                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1245                                 }
1246                                 daa_set_mode(j, SOP_PU_SLEEP);
1247                                 j->pstn_winkstart = 0;
1248                                 j->ex.bits.pstn_wink = 1;
1249                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1250                         }
1251                         break;
1252         }
1253 }
1254
1255 static void ixj_timeout(unsigned long ptr)
1256 {
1257         int board;
1258         unsigned long jifon;
1259         IXJ *j = (IXJ *)ptr;
1260         board = j->board;
1261
1262         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1263                 ixj_perfmon(j->timerchecks);
1264                 j->hookstate = ixj_hookstate(j);
1265                 if (j->tone_state) {
1266                         if (!(j->hookstate)) {
1267                                 ixj_cpt_stop(j);
1268                                 if (j->m_hook) {
1269                                         j->m_hook = 0;
1270                                         j->ex.bits.hookstate = 1;
1271                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1272                                 }
1273                                 clear_bit(board, &j->busyflags);
1274                                 ixj_add_timer(j);
1275                                 return;
1276                         }
1277                         if (j->tone_state == 1)
1278                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1279                         else
1280                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1281                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1282                                 if (j->tone_state == 1) {
1283                                         ixj_play_tone(j, j->tone_index);
1284                                         if (j->dsp.low == 0x20) {
1285                                                 clear_bit(board, &j->busyflags);
1286                                                 ixj_add_timer(j);
1287                                                 return;
1288                                         }
1289                                 } else {
1290                                         ixj_play_tone(j, 0);
1291                                         if (j->dsp.low == 0x20) {
1292                                                 clear_bit(board, &j->busyflags);
1293                                                 ixj_add_timer(j);
1294                                                 return;
1295                                         }
1296                                 }
1297                         } else {
1298                                 ixj_tone_timeout(j);
1299                                 if (j->flags.dialtone) {
1300                                         ixj_dialtone(j);
1301                                 }
1302                                 if (j->flags.busytone) {
1303                                         ixj_busytone(j);
1304                                         if (j->dsp.low == 0x20) {
1305                                                 clear_bit(board, &j->busyflags);
1306                                                 ixj_add_timer(j);
1307                                                 return;
1308                                         }
1309                                 }
1310                                 if (j->flags.ringback) {
1311                                         ixj_ringback(j);
1312                                         if (j->dsp.low == 0x20) {
1313                                                 clear_bit(board, &j->busyflags);
1314                                                 ixj_add_timer(j);
1315                                                 return;
1316                                         }
1317                                 }
1318                                 if (!j->tone_state) {
1319                                         ixj_cpt_stop(j);
1320                                 }
1321                         }
1322                 }
1323                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1324                         if (IsRxReady(j)) {
1325                                 ixj_read_frame(j);
1326                         }
1327                         if (IsTxReady(j)) {
1328                                 ixj_write_frame(j);
1329                         }
1330                 }
1331                 if (j->flags.cringing) {
1332                         if (j->hookstate & 1) {
1333                                 j->flags.cringing = 0;
1334                                 ixj_ring_off(j);
1335                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1336                                 switch(j->cadence_f[5].state) {
1337                                         case 0:
1338                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1339                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1340                                                         if(ixjdebug & 0x0004) {
1341                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1342                                                         }
1343                                                         ixj_ring_on(j);
1344                                                 }
1345                                                 j->cadence_f[5].state = 1;
1346                                                 break;
1347                                         case 1:
1348                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1349                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1350                                                         if(ixjdebug & 0x0004) {
1351                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1352                                                         }
1353                                                         ixj_ring_off(j);
1354                                                         j->cadence_f[5].state = 2;
1355                                                 }
1356                                                 break;
1357                                         case 2:
1358                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1359                                                         if(ixjdebug & 0x0004) {
1360                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1361                                                         }
1362                                                         ixj_ring_on(j);
1363                                                         if (j->cadence_f[5].on2) {
1364                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1365                                                                 j->cadence_f[5].state = 3;
1366                                                         } else {
1367                                                                 j->cadence_f[5].state = 7;
1368                                                         }
1369                                                 }
1370                                                 break;
1371                                         case 3:
1372                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1373                                                         if(ixjdebug & 0x0004) {
1374                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1375                                                         }
1376                                                         ixj_ring_off(j);
1377                                                         if (j->cadence_f[5].off2) {
1378                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1379                                                                 j->cadence_f[5].state = 4;
1380                                                         } else {
1381                                                                 j->cadence_f[5].state = 7;
1382                                                         }
1383                                                 }
1384                                                 break;
1385                                         case 4:
1386                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1387                                                         if(ixjdebug & 0x0004) {
1388                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1389                                                         }
1390                                                         ixj_ring_on(j);
1391                                                         if (j->cadence_f[5].on3) {
1392                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1393                                                                 j->cadence_f[5].state = 5;
1394                                                         } else {
1395                                                                 j->cadence_f[5].state = 7;
1396                                                         }
1397                                                 }
1398                                                 break;
1399                                         case 5:
1400                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1401                                                         if(ixjdebug & 0x0004) {
1402                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1403                                                         }
1404                                                         ixj_ring_off(j);
1405                                                         if (j->cadence_f[5].off3) {
1406                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1407                                                                 j->cadence_f[5].state = 6;
1408                                                         } else {
1409                                                                 j->cadence_f[5].state = 7;
1410                                                         }
1411                                                 }
1412                                                 break;
1413                                         case 6:
1414                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1415                                                         if(ixjdebug & 0x0004) {
1416                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1417                                                         }
1418                                                         j->cadence_f[5].state = 7;
1419                                                 }
1420                                                 break;
1421                                         case 7:
1422                                                 if(ixjdebug & 0x0004) {
1423                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1424                                                 }
1425                                                 j->flags.cidring = 1;
1426                                                 j->cadence_f[5].state = 0;
1427                                                 break;
1428                                 }
1429                                 if (j->flags.cidring && !j->flags.cidsent) {
1430                                         j->flags.cidsent = 1;
1431                                         if(j->fskdcnt) {
1432                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1433                                                 ixj_pre_cid(j);
1434                                         }
1435                                         j->flags.cidring = 0;
1436                                 }
1437                                 clear_bit(board, &j->busyflags);
1438                                 ixj_add_timer(j);
1439                                 return;
1440                         } else {
1441                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1442                                         if (j->flags.cidring && !j->flags.cidsent) {
1443                                                 j->flags.cidsent = 1;
1444                                                 if(j->fskdcnt) {
1445                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1446                                                         ixj_pre_cid(j);
1447                                                 }
1448                                                 j->flags.cidring = 0;
1449                                         }
1450                                         j->ring_cadence_t--;
1451                                         if (j->ring_cadence_t == -1)
1452                                                 j->ring_cadence_t = 15;
1453                                         j->ring_cadence_jif = jiffies;
1454
1455                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1456                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1457                                                         j->flags.firstring = 1;
1458                                                 else
1459                                                         ixj_ring_on(j);
1460                                         } else {
1461                                                 ixj_ring_off(j);
1462                                                 if(!j->flags.cidsent)
1463                                                         j->flags.cidring = 1;
1464                                         }
1465                                 }
1466                                 clear_bit(board, &j->busyflags);
1467                                 ixj_add_timer(j);
1468                                 return;
1469                         }
1470                 }
1471                 if (!j->flags.ringing) {
1472                         if (j->hookstate) { /* & 1) { */
1473                                 if (j->dsp.low != 0x20 &&
1474                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1475                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1476                                 }
1477                                 LineMonitor(j);
1478                                 read_filters(j);
1479                                 ixj_WriteDSPCommand(0x511B, j);
1480                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1481                                 if (!j->m_hook && (j->hookstate & 1)) {
1482                                         j->m_hook = j->ex.bits.hookstate = 1;
1483                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1484                                 }
1485                         } else {
1486                                 if (j->ex.bits.dtmf_ready) {
1487                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1488                                 }
1489                                 if (j->m_hook) {
1490                                         j->m_hook = 0;
1491                                         j->ex.bits.hookstate = 1;
1492                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1493                                 }
1494                         }
1495                 }
1496                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1497                         ixj_pstn_state(j);
1498                 }
1499                 if (j->ex.bytes) {
1500                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1501                 }
1502                 clear_bit(board, &j->busyflags);
1503         }
1504         ixj_add_timer(j);
1505 }
1506
1507 static int ixj_status_wait(IXJ *j)
1508 {
1509         unsigned long jif;
1510
1511         jif = jiffies + ((60 * hertz) / 100);
1512         while (!IsStatusReady(j)) {
1513                 ixj_perfmon(j->statuswait);
1514                 if (time_after(jiffies, jif)) {
1515                         ixj_perfmon(j->statuswaitfail);
1516                         return -1;
1517                 }
1518         }
1519         return 0;
1520 }
1521
1522 static int ixj_PCcontrol_wait(IXJ *j)
1523 {
1524         unsigned long jif;
1525
1526         jif = jiffies + ((60 * hertz) / 100);
1527         while (!IsPCControlReady(j)) {
1528                 ixj_perfmon(j->pcontrolwait);
1529                 if (time_after(jiffies, jif)) {
1530                         ixj_perfmon(j->pcontrolwaitfail);
1531                         return -1;
1532                 }
1533         }
1534         return 0;
1535 }
1536
1537 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1538 {
1539         BYTES bytes;
1540         unsigned long jif;
1541
1542         atomic_inc(&j->DSPWrite);
1543         if(atomic_read(&j->DSPWrite) > 1) {
1544                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1545                 return -1;
1546         }
1547         bytes.high = (cmd & 0xFF00) >> 8;
1548         bytes.low = cmd & 0x00FF;
1549         jif = jiffies + ((60 * hertz) / 100);
1550         while (!IsControlReady(j)) {
1551                 ixj_perfmon(j->iscontrolready);
1552                 if (time_after(jiffies, jif)) {
1553                         ixj_perfmon(j->iscontrolreadyfail);
1554                         atomic_dec(&j->DSPWrite);
1555                         if(atomic_read(&j->DSPWrite) > 0) {
1556                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1557                                 while(atomic_read(&j->DSPWrite) > 0) {
1558                                         atomic_dec(&j->DSPWrite);
1559                                 }
1560                         }
1561                         return -1;
1562                 }
1563         }
1564         outb(bytes.low, j->DSPbase + 6);
1565         outb(bytes.high, j->DSPbase + 7);
1566
1567         if (ixj_status_wait(j)) {
1568                 j->ssr.low = 0xFF;
1569                 j->ssr.high = 0xFF;
1570                 atomic_dec(&j->DSPWrite);
1571                 if(atomic_read(&j->DSPWrite) > 0) {
1572                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1573                         while(atomic_read(&j->DSPWrite) > 0) {
1574                                 atomic_dec(&j->DSPWrite);
1575                         }
1576                 }
1577                 return -1;
1578         }
1579 /* Read Software Status Register */
1580         j->ssr.low = inb_p(j->DSPbase + 2);
1581         j->ssr.high = inb_p(j->DSPbase + 3);
1582         atomic_dec(&j->DSPWrite);
1583         if(atomic_read(&j->DSPWrite) > 0) {
1584                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1585                 while(atomic_read(&j->DSPWrite) > 0) {
1586                         atomic_dec(&j->DSPWrite);
1587                 }
1588         }
1589         return 0;
1590 }
1591
1592 /***************************************************************************
1593 *
1594 *  General Purpose IO Register read routine
1595 *
1596 ***************************************************************************/
1597 static inline int ixj_gpio_read(IXJ *j)
1598 {
1599         if (ixj_WriteDSPCommand(0x5143, j))
1600                 return -1;
1601
1602         j->gpio.bytes.low = j->ssr.low;
1603         j->gpio.bytes.high = j->ssr.high;
1604
1605         return 0;
1606 }
1607
1608 static inline void LED_SetState(int state, IXJ *j)
1609 {
1610         if (j->cardtype == QTI_LINEJACK) {
1611                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1612                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1613                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1614                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1615
1616                 outb(j->pld_scrw.byte, j->XILINXbase);
1617         }
1618 }
1619
1620 /*********************************************************************
1621 *  GPIO Pins are configured as follows on the Quicknet Internet
1622 *  PhoneJACK Telephony Cards
1623 *
1624 * POTS Select        GPIO_6=0 GPIO_7=0
1625 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1626 * Handset Select     GPIO_6=1 GPIO_7=0
1627 *
1628 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1629 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1630 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1631 *
1632 * Hook Switch changes reported on GPIO_3
1633 *********************************************************************/
1634 static int ixj_set_port(IXJ *j, int arg)
1635 {
1636         if (j->cardtype == QTI_PHONEJACK_LITE) {
1637                 if (arg != PORT_POTS)
1638                         return 10;
1639                 else
1640                         return 0;
1641         }
1642         switch (arg) {
1643         case PORT_POTS:
1644                 j->port = PORT_POTS;
1645                 switch (j->cardtype) {
1646                 case QTI_PHONECARD:
1647                         if (j->flags.pcmciasct == 1)
1648                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1649                         else
1650                                 return 11;
1651                         break;
1652                 case QTI_PHONEJACK_PCI:
1653                         j->pld_slicw.pcib.mic = 0;
1654                         j->pld_slicw.pcib.spk = 0;
1655                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1656                         break;
1657                 case QTI_LINEJACK:
1658                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1659                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1660                                                                            Software Control Register */
1661                                 return 2;
1662                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1663
1664                         outb(j->pld_scrw.byte, j->XILINXbase);
1665                         j->pld_clock.byte = 0;
1666                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1667                         j->pld_slicw.bits.rly1 = 1;
1668                         j->pld_slicw.bits.spken = 0;
1669                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1670                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1671                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1672                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1673                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1674                         ixj_mixer(0x0E80, j);   /*Mic mute */
1675                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1676                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1677                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1678                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1679 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1680                         break;
1681                 case QTI_PHONEJACK:
1682                         j->gpio.bytes.high = 0x0B;
1683                         j->gpio.bits.gpio6 = 0;
1684                         j->gpio.bits.gpio7 = 0;
1685                         ixj_WriteDSPCommand(j->gpio.word, j);
1686                         break;
1687                 }
1688                 break;
1689         case PORT_PSTN:
1690                 if (j->cardtype == QTI_LINEJACK) {
1691                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1692
1693                         j->pld_slicw.bits.rly3 = 0;
1694                         j->pld_slicw.bits.rly1 = 1;
1695                         j->pld_slicw.bits.spken = 0;
1696                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1697                         j->port = PORT_PSTN;
1698                 } else {
1699                         return 4;
1700                 }
1701                 break;
1702         case PORT_SPEAKER:
1703                 j->port = PORT_SPEAKER;
1704                 switch (j->cardtype) {
1705                 case QTI_PHONECARD:
1706                         if (j->flags.pcmciasct) {
1707                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1708                         }
1709                         break;
1710                 case QTI_PHONEJACK_PCI:
1711                         j->pld_slicw.pcib.mic = 1;
1712                         j->pld_slicw.pcib.spk = 1;
1713                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1714                         break;
1715                 case QTI_LINEJACK:
1716                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1717                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1718                                                                            Software Control Register */
1719                                 return 2;
1720                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1721
1722                         outb(j->pld_scrw.byte, j->XILINXbase);
1723                         j->pld_clock.byte = 0;
1724                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1725                         j->pld_slicw.bits.rly1 = 1;
1726                         j->pld_slicw.bits.spken = 1;
1727                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1728                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1729                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1730                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1731                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1732                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1733                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1734                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1735                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1736                         break;
1737                 case QTI_PHONEJACK:
1738                         j->gpio.bytes.high = 0x0B;
1739                         j->gpio.bits.gpio6 = 0;
1740                         j->gpio.bits.gpio7 = 1;
1741                         ixj_WriteDSPCommand(j->gpio.word, j);
1742                         break;
1743                 }
1744                 break;
1745         case PORT_HANDSET:
1746                 if (j->cardtype != QTI_PHONEJACK) {
1747                         return 5;
1748                 } else {
1749                         j->gpio.bytes.high = 0x0B;
1750                         j->gpio.bits.gpio6 = 1;
1751                         j->gpio.bits.gpio7 = 0;
1752                         ixj_WriteDSPCommand(j->gpio.word, j);
1753                         j->port = PORT_HANDSET;
1754                 }
1755                 break;
1756         default:
1757                 return 6;
1758                 break;
1759         }
1760         return 0;
1761 }
1762
1763 static int ixj_set_pots(IXJ *j, int arg)
1764 {
1765         if (j->cardtype == QTI_LINEJACK) {
1766                 if (arg) {
1767                         if (j->port == PORT_PSTN) {
1768                                 j->pld_slicw.bits.rly1 = 0;
1769                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1770                                 j->flags.pots_pstn = 1;
1771                                 return 1;
1772                         } else {
1773                                 j->flags.pots_pstn = 0;
1774                                 return 0;
1775                         }
1776                 } else {
1777                         j->pld_slicw.bits.rly1 = 1;
1778                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1779                         j->flags.pots_pstn = 0;
1780                         return 1;
1781                 }
1782         } else {
1783                 return 0;
1784         }
1785 }
1786
1787 static void ixj_ring_on(IXJ *j)
1788 {
1789         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1790          {
1791                 if (ixjdebug & 0x0004)
1792                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1793
1794                 j->gpio.bytes.high = 0x0B;
1795                 j->gpio.bytes.low = 0x00;
1796                 j->gpio.bits.gpio1 = 1;
1797                 j->gpio.bits.gpio2 = 1;
1798                 j->gpio.bits.gpio5 = 0;
1799                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1800         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1801         {
1802                 if (ixjdebug & 0x0004)
1803                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1804
1805                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1806         }
1807 }
1808
1809 static int ixj_siadc(IXJ *j, int val)
1810 {
1811         if(j->cardtype == QTI_PHONECARD){
1812                 if(j->flags.pcmciascp){
1813                         if(val == -1)
1814                                 return j->siadc.bits.rxg;
1815
1816                         if(val < 0 || val > 0x1F)
1817                                 return -1;
1818
1819                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1820                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1821                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1822                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1823                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1824                         j->psccr.bits.dev = 0;
1825                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1826                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1827                         ixj_PCcontrol_wait(j);
1828                         return j->siadc.bits.rxg;
1829                 }
1830         }
1831         return -1;
1832 }
1833
1834 static int ixj_sidac(IXJ *j, int val)
1835 {
1836         if(j->cardtype == QTI_PHONECARD){
1837                 if(j->flags.pcmciascp){
1838                         if(val == -1)
1839                                 return j->sidac.bits.txg;
1840
1841                         if(val < 0 || val > 0x1F)
1842                                 return -1;
1843
1844                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1845                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1846                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1847                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1848                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1849                         j->psccr.bits.dev = 0;
1850                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1851                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1852                         ixj_PCcontrol_wait(j);
1853                         return j->sidac.bits.txg;
1854                 }
1855         }
1856         return -1;
1857 }
1858
1859 static int ixj_pcmcia_cable_check(IXJ *j)
1860 {
1861         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1862         if (!j->flags.pcmciastate) {
1863                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1864                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1865                         j->flags.pcmciastate = 4;
1866                         return 0;
1867                 }
1868                 if (j->pccr1.bits.ed) {
1869                         j->pccr1.bits.ed = 0;
1870                         j->psccr.bits.dev = 3;
1871                         j->psccr.bits.rw = 1;
1872                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1873                         ixj_PCcontrol_wait(j);
1874                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1875                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1876                         j->psccr.bits.dev = 3;
1877                         j->psccr.bits.rw = 0;
1878                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1879                         ixj_PCcontrol_wait(j);
1880                         return j->pslic.bits.led2 ? 1 : 0;
1881                 } else if (j->flags.pcmciasct) {
1882                         return j->r_hook;
1883                 } else {
1884                         return 1;
1885                 }
1886         } else if (j->flags.pcmciastate == 4) {
1887                 if (!j->pccr1.bits.drf) {
1888                         j->flags.pcmciastate = 3;
1889                 }
1890                 return 0;
1891         } else if (j->flags.pcmciastate == 3) {
1892                 j->pccr2.bits.pwr = 0;
1893                 j->pccr2.bits.rstc = 1;
1894                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1895                 j->checkwait = jiffies + (hertz * 2);
1896                 j->flags.incheck = 1;
1897                 j->flags.pcmciastate = 2;
1898                 return 0;
1899         } else if (j->flags.pcmciastate == 2) {
1900                 if (j->flags.incheck) {
1901                         if (time_before(jiffies, j->checkwait)) {
1902                                 return 0;
1903                         } else {
1904                                 j->flags.incheck = 0;
1905                         }
1906                 }
1907                 j->pccr2.bits.pwr = 0;
1908                 j->pccr2.bits.rstc = 0;
1909                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1910                 j->flags.pcmciastate = 1;
1911                 return 0;
1912         } else if (j->flags.pcmciastate == 1) {
1913                 j->flags.pcmciastate = 0;
1914                 if (!j->pccr1.bits.drf) {
1915                         j->psccr.bits.dev = 3;
1916                         j->psccr.bits.rw = 1;
1917                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1918                         ixj_PCcontrol_wait(j);
1919                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1920
1921                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1922
1923                         if (j->flags.pcmciasct == 3) {
1924                                 j->flags.pcmciastate = 4;
1925                                 return 0;
1926                         } else if (j->flags.pcmciasct == 0) {
1927                                 j->pccr2.bits.pwr = 1;
1928                                 j->pccr2.bits.rstc = 0;
1929                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1930                                 j->port = PORT_SPEAKER;
1931                         } else {
1932                                 j->port = PORT_POTS;
1933                         }
1934                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1935                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1936                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1937                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1938                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1939                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1940                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1941                         j->psccr.bits.dev = 0;
1942                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1943                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1944                         ixj_PCcontrol_wait(j);
1945
1946                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1947                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1948                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1949                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1950                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1951                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1952                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1953                         j->psccr.bits.dev = 0;
1954                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1955                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1956                         ixj_PCcontrol_wait(j);
1957
1958                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1959                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1960                         j->psccr.bits.dev = 0;
1961                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1962                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1963                         ixj_PCcontrol_wait(j);
1964
1965                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1966                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1967                         j->psccr.bits.dev = 0;
1968                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1969                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1970                         ixj_PCcontrol_wait(j);
1971
1972                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1973                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1974                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1975                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1976                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1977                         j->sirxg.bits.iir = 1;                          /* IIR */
1978                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1979                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1980                         j->psccr.bits.dev = 0;
1981                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1982                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1983                         ixj_PCcontrol_wait(j);
1984
1985                         ixj_siadc(j, 0x17);
1986                         ixj_sidac(j, 0x1D);
1987
1988                         j->siaatt.bits.sot = 0;
1989                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1990                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1991                         j->psccr.bits.dev = 0;
1992                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1993                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1994                         ixj_PCcontrol_wait(j);
1995
1996                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1997                                 j->psccr.byte = j->pslic.byte = 0;
1998                                 j->pslic.bits.powerdown = 1;
1999                                 j->psccr.bits.dev = 3;
2000                                 j->psccr.bits.rw = 0;
2001                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2002                                 ixj_PCcontrol_wait(j);
2003                         }
2004                 }
2005                 return 0;
2006         } else {
2007                 j->flags.pcmciascp = 0;
2008                 return 0;
2009         }
2010         return 0;
2011 }
2012
2013 static int ixj_hookstate(IXJ *j)
2014 {
2015         unsigned long det;
2016         int fOffHook = 0;
2017
2018         switch (j->cardtype) {
2019         case QTI_PHONEJACK:
2020                 ixj_gpio_read(j);
2021                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
2022                 break;
2023         case QTI_LINEJACK:
2024         case QTI_PHONEJACK_LITE:
2025         case QTI_PHONEJACK_PCI:
2026                 SLIC_GetState(j);
2027                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
2028                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
2029                         if(fOffHook != j->p_hook) {
2030                                 if(!j->checkwait) {
2031                                         j->checkwait = jiffies;
2032                                 }
2033                                 if(time_before(jiffies, j->checkwait + 2)) {
2034                                         fOffHook ^= 1;
2035                                 } else {
2036                                         j->checkwait = 0;
2037                                 }
2038                                 j->p_hook = fOffHook;
2039                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
2040                         }
2041                 } else {
2042                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
2043                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
2044                                 if (j->flags.ringing || j->flags.cringing) {
2045                                         if (!in_interrupt()) {
2046                                                 det = jiffies + (hertz / 50);
2047                                                 while (time_before(jiffies, det)) {
2048                                                         set_current_state(TASK_INTERRUPTIBLE);
2049                                                         schedule_timeout(1);
2050                                                 }
2051                                         }
2052                                         SLIC_GetState(j);
2053                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
2054                                                 ixj_ring_on(j);
2055                                         }
2056                                 }
2057                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
2058                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
2059                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
2060                                 } else
2061                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
2062                         }
2063                 }
2064                 break;
2065         case QTI_PHONECARD:
2066                 fOffHook = ixj_pcmcia_cable_check(j);
2067                 break;
2068         }
2069         if (j->r_hook != fOffHook) {
2070                 j->r_hook = fOffHook;
2071                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
2072                         j->ex.bits.hookstate = 1;
2073                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
2074                 } else if (!fOffHook) {
2075                         j->flash_end = jiffies + ((60 * hertz) / 100);
2076                 }
2077         }
2078         if (fOffHook) {
2079                 if(time_before(jiffies, j->flash_end)) {
2080                         j->ex.bits.flash = 1;
2081                         j->flash_end = 0;
2082                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
2083                 }
2084         } else {
2085                 if(time_before(jiffies, j->flash_end)) {
2086                         fOffHook = 1;
2087                 }
2088         }
2089
2090         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
2091                 fOffHook |= 2;
2092
2093         if (j->port == PORT_SPEAKER) {
2094                 if(j->cardtype == QTI_PHONECARD) {
2095                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
2096                                 fOffHook |= 2;
2097                         }
2098                 } else {
2099                         fOffHook |= 2;
2100                 }
2101         }
2102
2103         if (j->port == PORT_HANDSET)
2104                 fOffHook |= 2;
2105
2106         return fOffHook;
2107 }
2108
2109 static void ixj_ring_off(IXJ *j)
2110 {
2111         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2112          {
2113                 if (ixjdebug & 0x0004)
2114                         printk(KERN_INFO "IXJ Ring Off\n");
2115                 j->gpio.bytes.high = 0x0B;
2116                 j->gpio.bytes.low = 0x00;
2117                 j->gpio.bits.gpio1 = 0;
2118                 j->gpio.bits.gpio2 = 1;
2119                 j->gpio.bits.gpio5 = 0;
2120                 ixj_WriteDSPCommand(j->gpio.word, j);
2121         } else                  /* Internet LineJACK */
2122         {
2123                 if (ixjdebug & 0x0004)
2124                         printk(KERN_INFO "IXJ Ring Off\n");
2125
2126                 if(!j->flags.cidplay)
2127                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2128
2129                 SLIC_GetState(j);
2130         }
2131 }
2132
2133 static void ixj_ring_start(IXJ *j)
2134 {
2135         j->flags.cringing = 1;
2136         if (ixjdebug & 0x0004)
2137                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2138         if (ixj_hookstate(j) & 1) {
2139                 if (j->port == PORT_POTS)
2140                         ixj_ring_off(j);
2141                 j->flags.cringing = 0;
2142                 if (ixjdebug & 0x0004)
2143                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2144         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2145                 j->ring_cadence_jif = jiffies;
2146                 j->flags.cidsent = j->flags.cidring = 0;
2147                 j->cadence_f[5].state = 0;
2148                 if(j->cadence_f[5].on1)
2149                         ixj_ring_on(j);
2150         } else {
2151                 j->ring_cadence_jif = jiffies;
2152                 j->ring_cadence_t = 15;
2153                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2154                         ixj_ring_on(j);
2155                 } else {
2156                         ixj_ring_off(j);
2157                 }
2158                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2159         }
2160 }
2161
2162 static int ixj_ring(IXJ *j)
2163 {
2164         char cntr;
2165         unsigned long jif, det;
2166
2167         j->flags.ringing = 1;
2168         if (ixj_hookstate(j) & 1) {
2169                 ixj_ring_off(j);
2170                 j->flags.ringing = 0;
2171                 return 1;
2172         }
2173         det = 0;
2174         for (cntr = 0; cntr < j->maxrings; cntr++) {
2175                 jif = jiffies + (1 * hertz);
2176                 ixj_ring_on(j);
2177                 while (time_before(jiffies, jif)) {
2178                         if (ixj_hookstate(j) & 1) {
2179                                 ixj_ring_off(j);
2180                                 j->flags.ringing = 0;
2181                                 return 1;
2182                         }
2183                         set_current_state(TASK_INTERRUPTIBLE);
2184                         schedule_timeout(1);
2185                         if (signal_pending(current))
2186                                 break;
2187                 }
2188                 jif = jiffies + (3 * hertz);
2189                 ixj_ring_off(j);
2190                 while (time_before(jiffies, jif)) {
2191                         if (ixj_hookstate(j) & 1) {
2192                                 det = jiffies + (hertz / 100);
2193                                 while (time_before(jiffies, det)) {
2194                                         set_current_state(TASK_INTERRUPTIBLE);
2195                                         schedule_timeout(1);
2196                                         if (signal_pending(current))
2197                                                 break;
2198                                 }
2199                                 if (ixj_hookstate(j) & 1) {
2200                                         j->flags.ringing = 0;
2201                                         return 1;
2202                                 }
2203                         }
2204                         set_current_state(TASK_INTERRUPTIBLE);
2205                         schedule_timeout(1);
2206                         if (signal_pending(current))
2207                                 break;
2208                 }
2209         }
2210         ixj_ring_off(j);
2211         j->flags.ringing = 0;
2212         return 0;
2213 }
2214
2215 static int ixj_open(struct phone_device *p, struct file *file_p)
2216 {
2217         IXJ *j = get_ixj(p->board);
2218         file_p->private_data = j;
2219
2220         if (!j->DSPbase)
2221                 return -ENODEV;
2222
2223         if (file_p->f_mode & FMODE_READ) {
2224                 if(!j->readers) {
2225                         j->readers++;
2226                 } else {
2227                         return -EBUSY;
2228                 }
2229         }
2230
2231         if (file_p->f_mode & FMODE_WRITE) {
2232                 if(!j->writers) {
2233                         j->writers++;
2234                 } else {
2235                         if (file_p->f_mode & FMODE_READ){
2236                                 j->readers--;
2237                         }
2238                         return -EBUSY;
2239                 }
2240         }
2241
2242         if (j->cardtype == QTI_PHONECARD) {
2243                 j->pslic.bits.powerdown = 0;
2244                 j->psccr.bits.dev = 3;
2245                 j->psccr.bits.rw = 0;
2246                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2247                 ixj_PCcontrol_wait(j);
2248         }
2249
2250         j->flags.cidplay = 0;
2251         j->flags.cidcw_ack = 0;
2252
2253         if (ixjdebug & 0x0002)
2254                 printk(KERN_INFO "Opening board %d\n", p->board);
2255
2256         j->framesread = j->frameswritten = 0;
2257         return 0;
2258 }
2259
2260 int ixj_release(struct inode *inode, struct file *file_p)
2261 {
2262         IXJ_TONE ti;
2263         int cnt;
2264         IXJ *j = file_p->private_data;
2265         int board = j->p.board;
2266
2267         /*
2268          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2269          *    This is necessary to keep the DSP from locking up.
2270          */
2271         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2272                 set_current_state(TASK_INTERRUPTIBLE);
2273                 schedule_timeout(1);
2274         }
2275         if (ixjdebug & 0x0002)
2276                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2277
2278         if (j->cardtype == QTI_PHONECARD)
2279                 ixj_set_port(j, PORT_SPEAKER);
2280         else
2281                 ixj_set_port(j, PORT_POTS);
2282
2283         aec_stop(j);
2284         ixj_play_stop(j);
2285         ixj_record_stop(j);
2286         set_play_volume(j, 0x100);
2287         set_rec_volume(j, 0x100);
2288         ixj_ring_off(j);
2289
2290         /* Restore the tone table to default settings. */
2291         ti.tone_index = 10;
2292         ti.gain0 = 1;
2293         ti.freq0 = hz941;
2294         ti.gain1 = 0;
2295         ti.freq1 = hz1209;
2296         ixj_init_tone(j, &ti);
2297         ti.tone_index = 11;
2298         ti.gain0 = 1;
2299         ti.freq0 = hz941;
2300         ti.gain1 = 0;
2301         ti.freq1 = hz1336;
2302         ixj_init_tone(j, &ti);
2303         ti.tone_index = 12;
2304         ti.gain0 = 1;
2305         ti.freq0 = hz941;
2306         ti.gain1 = 0;
2307         ti.freq1 = hz1477;
2308         ixj_init_tone(j, &ti);
2309         ti.tone_index = 13;
2310         ti.gain0 = 1;
2311         ti.freq0 = hz800;
2312         ti.gain1 = 0;
2313         ti.freq1 = 0;
2314         ixj_init_tone(j, &ti);
2315         ti.tone_index = 14;
2316         ti.gain0 = 1;
2317         ti.freq0 = hz1000;
2318         ti.gain1 = 0;
2319         ti.freq1 = 0;
2320         ixj_init_tone(j, &ti);
2321         ti.tone_index = 15;
2322         ti.gain0 = 1;
2323         ti.freq0 = hz1250;
2324         ti.gain1 = 0;
2325         ti.freq1 = 0;
2326         ixj_init_tone(j, &ti);
2327         ti.tone_index = 16;
2328         ti.gain0 = 1;
2329         ti.freq0 = hz950;
2330         ti.gain1 = 0;
2331         ti.freq1 = 0;
2332         ixj_init_tone(j, &ti);
2333         ti.tone_index = 17;
2334         ti.gain0 = 1;
2335         ti.freq0 = hz1100;
2336         ti.gain1 = 0;
2337         ti.freq1 = 0;
2338         ixj_init_tone(j, &ti);
2339         ti.tone_index = 18;
2340         ti.gain0 = 1;
2341         ti.freq0 = hz1400;
2342         ti.gain1 = 0;
2343         ti.freq1 = 0;
2344         ixj_init_tone(j, &ti);
2345         ti.tone_index = 19;
2346         ti.gain0 = 1;
2347         ti.freq0 = hz1500;
2348         ti.gain1 = 0;
2349         ti.freq1 = 0;
2350         ixj_init_tone(j, &ti);
2351         ti.tone_index = 20;
2352         ti.gain0 = 1;
2353         ti.freq0 = hz1600;
2354         ti.gain1 = 0;
2355         ti.freq1 = 0;
2356         ixj_init_tone(j, &ti);
2357         ti.tone_index = 21;
2358         ti.gain0 = 1;
2359         ti.freq0 = hz1800;
2360         ti.gain1 = 0;
2361         ti.freq1 = 0;
2362         ixj_init_tone(j, &ti);
2363         ti.tone_index = 22;
2364         ti.gain0 = 1;
2365         ti.freq0 = hz2100;
2366         ti.gain1 = 0;
2367         ti.freq1 = 0;
2368         ixj_init_tone(j, &ti);
2369         ti.tone_index = 23;
2370         ti.gain0 = 1;
2371         ti.freq0 = hz1300;
2372         ti.gain1 = 0;
2373         ti.freq1 = 0;
2374         ixj_init_tone(j, &ti);
2375         ti.tone_index = 24;
2376         ti.gain0 = 1;
2377         ti.freq0 = hz2450;
2378         ti.gain1 = 0;
2379         ti.freq1 = 0;
2380         ixj_init_tone(j, &ti);
2381         ti.tone_index = 25;
2382         ti.gain0 = 1;
2383         ti.freq0 = hz350;
2384         ti.gain1 = 0;
2385         ti.freq1 = hz440;
2386         ixj_init_tone(j, &ti);
2387         ti.tone_index = 26;
2388         ti.gain0 = 1;
2389         ti.freq0 = hz440;
2390         ti.gain1 = 0;
2391         ti.freq1 = hz480;
2392         ixj_init_tone(j, &ti);
2393         ti.tone_index = 27;
2394         ti.gain0 = 1;
2395         ti.freq0 = hz480;
2396         ti.gain1 = 0;
2397         ti.freq1 = hz620;
2398         ixj_init_tone(j, &ti);
2399
2400         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2401
2402         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2403
2404         j->ex.bits.dtmf_ready = 0;
2405         j->dtmf_state = 0;
2406         j->dtmf_wp = j->dtmf_rp = 0;
2407         j->rec_mode = j->play_mode = -1;
2408         j->flags.ringing = 0;
2409         j->maxrings = MAXRINGS;
2410         j->ring_cadence = USA_RING_CADENCE;
2411         if(j->cadence_f[5].enable) {
2412                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2413         }
2414         j->drybuffer = 0;
2415         j->winktime = 320;
2416         j->flags.dtmf_oob = 0;
2417         for (cnt = 0; cnt < 4; cnt++)
2418                 j->cadence_f[cnt].enable = 0;
2419
2420         idle(j);
2421
2422         if(j->cardtype == QTI_PHONECARD) {
2423                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2424         }
2425
2426         if (file_p->f_mode & FMODE_READ)
2427                 j->readers--;
2428         if (file_p->f_mode & FMODE_WRITE)
2429                 j->writers--;
2430
2431         if (j->read_buffer && !j->readers) {
2432                 kfree(j->read_buffer);
2433                 j->read_buffer = NULL;
2434                 j->read_buffer_size = 0;
2435         }
2436         if (j->write_buffer && !j->writers) {
2437                 kfree(j->write_buffer);
2438                 j->write_buffer = NULL;
2439                 j->write_buffer_size = 0;
2440         }
2441         j->rec_codec = j->play_codec = 0;
2442         j->rec_frame_size = j->play_frame_size = 0;
2443         j->flags.cidsent = j->flags.cidring = 0;
2444         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2445
2446         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2447                 ixj_set_port(j, PORT_PSTN);
2448                 daa_set_mode(j, SOP_PU_SLEEP);
2449                 ixj_set_pots(j, 1);
2450         }
2451         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2452
2453         /* Set up the default signals for events */
2454         for (cnt = 0; cnt < 35; cnt++)
2455                 j->ixj_signals[cnt] = SIGIO;
2456
2457         /* Set the excetion signal enable flags */
2458         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2459         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 =
2460         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;
2461
2462         file_p->private_data = NULL;
2463         clear_bit(board, &j->busyflags);
2464         return 0;
2465 }
2466
2467 static int read_filters(IXJ *j)
2468 {
2469         unsigned short fc, cnt, trg;
2470         int var;
2471
2472         trg = 0;
2473         if (ixj_WriteDSPCommand(0x5144, j)) {
2474                 if(ixjdebug & 0x0001) {
2475                         printk(KERN_INFO "Read Frame Counter failed!\n");
2476                 }
2477                 return -1;
2478         }
2479         fc = j->ssr.high << 8 | j->ssr.low;
2480         if (fc == j->frame_count)
2481                 return 1;
2482
2483         j->frame_count = fc;
2484
2485         if (j->dtmf_proc)
2486                 return 1;
2487
2488         var = 10;
2489
2490         for (cnt = 0; cnt < 4; cnt++) {
2491                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2492                         if(ixjdebug & 0x0001) {
2493                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2494                         }
2495                         return -1;
2496                 }
2497                 if (ixj_WriteDSPCommand(0x515C, j)) {
2498                         if(ixjdebug & 0x0001) {
2499                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2500                         }
2501                         return -1;
2502                 }
2503                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2504
2505                 if (j->cadence_f[cnt].enable) {
2506                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2507                                 if (j->cadence_f[cnt].state == 0) {
2508                                         j->cadence_f[cnt].state = 1;
2509                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2510                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2511                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2512                                 } else if (j->cadence_f[cnt].state == 2 &&
2513                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2514                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2515                                         if (j->cadence_f[cnt].on2) {
2516                                                 j->cadence_f[cnt].state = 3;
2517                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2518                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2519                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2520                                         } else {
2521                                                 j->cadence_f[cnt].state = 7;
2522                                         }
2523                                 } else if (j->cadence_f[cnt].state == 4 &&
2524                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2525                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2526                                         if (j->cadence_f[cnt].on3) {
2527                                                 j->cadence_f[cnt].state = 5;
2528                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2529                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2530                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2531                                         } else {
2532                                                 j->cadence_f[cnt].state = 7;
2533                                         }
2534                                 } else {
2535                                         j->cadence_f[cnt].state = 0;
2536                                 }
2537                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2538                                 if (j->cadence_f[cnt].state == 1) {
2539                                         if(!j->cadence_f[cnt].on1) {
2540                                                 j->cadence_f[cnt].state = 7;
2541                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2542                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2543                                                 if(j->cadence_f[cnt].off1) {
2544                                                         j->cadence_f[cnt].state = 2;
2545                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2546                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2547                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2548                                                 } else {
2549                                                         j->cadence_f[cnt].state = 7;
2550                                                 }
2551                                         } else {
2552                                                 j->cadence_f[cnt].state = 0;
2553                                         }
2554                                 } else if (j->cadence_f[cnt].state == 3) {
2555                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2556                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2557                                                 if(j->cadence_f[cnt].off2) {
2558                                                         j->cadence_f[cnt].state = 4;
2559                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2560                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2561                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2562                                                 } else {
2563                                                         j->cadence_f[cnt].state = 7;
2564                                                 }
2565                                         } else {
2566                                                 j->cadence_f[cnt].state = 0;
2567                                         }
2568                                 } else if (j->cadence_f[cnt].state == 5) {
2569                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2570                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2571                                                 if(j->cadence_f[cnt].off3) {
2572                                                         j->cadence_f[cnt].state = 6;
2573                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2574                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2575                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2576                                                 } else {
2577                                                         j->cadence_f[cnt].state = 7;
2578                                                 }
2579                                         } else {
2580                                                 j->cadence_f[cnt].state = 0;
2581                                         }
2582                                 } else {
2583                                         j->cadence_f[cnt].state = 0;
2584                                 }
2585                         } else {
2586                                 switch(j->cadence_f[cnt].state) {
2587                                         case 1:
2588                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2589                                                    !j->cadence_f[cnt].off1 &&
2590                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2591                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2592                                                         j->cadence_f[cnt].state = 7;
2593                                                 }
2594                                                 break;
2595                                         case 3:
2596                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2597                                                    !j->cadence_f[cnt].off2 &&
2598                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2599                                                         j->cadence_f[cnt].state = 7;
2600                                                 }
2601                                                 break;
2602                                         case 5:
2603                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2604                                                    !j->cadence_f[cnt].off3) {
2605                                                         j->cadence_f[cnt].state = 7;
2606                                                 }
2607                                                 break;
2608                                 }
2609                         }
2610
2611                         if (ixjdebug & 0x0040) {
2612                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2613                                 switch(j->cadence_f[cnt].state) {
2614                                         case 0:
2615                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2616                                                 break;
2617                                         case 1:
2618                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2619                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2620                                                 break;
2621                                         case 2:
2622                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2623                                                                                                                         j->cadence_f[cnt].off1max);
2624                                                 break;
2625                                         case 3:
2626                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2627                                                                                                                         j->cadence_f[cnt].on2max);
2628                                                 break;
2629                                         case 4:
2630                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2631                                                                                                                         j->cadence_f[cnt].off2max);
2632                                                 break;
2633                                         case 5:
2634                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2635                                                                                                                         j->cadence_f[cnt].on3max);
2636                                                 break;
2637                                         case 6:
2638                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2639                                                                                                                         j->cadence_f[cnt].off3max);
2640                                                 break;
2641                                 }
2642                         }
2643                 }
2644                 if (j->cadence_f[cnt].state == 7) {
2645                         j->cadence_f[cnt].state = 0;
2646                         if (j->cadence_f[cnt].enable == 1)
2647                                 j->cadence_f[cnt].enable = 0;
2648                         switch (cnt) {
2649                         case 0:
2650                                 if(ixjdebug & 0x0020) {
2651                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2652                                 }
2653                                 j->ex.bits.fc0 = 1;
2654                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2655                                 break;
2656                         case 1:
2657                                 if(ixjdebug & 0x0020) {
2658                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2659                                 }
2660                                 j->ex.bits.fc1 = 1;
2661                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2662                                 break;
2663                         case 2:
2664                                 if(ixjdebug & 0x0020) {
2665                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2666                                 }
2667                                 j->ex.bits.fc2 = 1;
2668                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2669                                 break;
2670                         case 3:
2671                                 if(ixjdebug & 0x0020) {
2672                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2673                                 }
2674                                 j->ex.bits.fc3 = 1;
2675                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2676                                 break;
2677                         }
2678                 }
2679                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2680                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2681                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2682                                 trg = 1;
2683                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2684                                 trg = 0;
2685                         }
2686                         switch (cnt) {
2687                         case 0:
2688                                 if(ixjdebug & 0x0020) {
2689                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2690                                 }
2691                                 j->ex.bits.f0 = 1;
2692                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2693                                 break;
2694                         case 1:
2695                                 if(ixjdebug & 0x0020) {
2696                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2697                                 }
2698                                 j->ex.bits.f1 = 1;
2699                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2700                                 break;
2701                         case 2:
2702                                 if(ixjdebug & 0x0020) {
2703                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2704                                 }
2705                                 j->ex.bits.f2 = 1;
2706                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2707                                 break;
2708                         case 3:
2709                                 if(ixjdebug & 0x0020) {
2710                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2711                                 }
2712                                 j->ex.bits.f3 = 1;
2713                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2714                                 break;
2715                         }
2716                 }
2717         }
2718         return 0;
2719 }
2720
2721 static int LineMonitor(IXJ *j)
2722 {
2723         if (j->dtmf_proc) {
2724                 return -1;
2725         }
2726         j->dtmf_proc = 1;
2727
2728         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2729                 return -1;
2730
2731         j->dtmf.bytes.high = j->ssr.high;
2732         j->dtmf.bytes.low = j->ssr.low;
2733         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2734                 j->dtmf_state = 1;
2735                 j->dtmf_current = j->dtmf.bits.digit;
2736         }
2737         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2738          {
2739                 if(!j->cidcw_wait) {
2740                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2741                         j->dtmf_wp++;
2742                         if (j->dtmf_wp == 79)
2743                                 j->dtmf_wp = 0;
2744                         j->ex.bits.dtmf_ready = 1;
2745                         if(j->ex_sig.bits.dtmf_ready) {
2746                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2747                         }
2748                 }
2749                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2750                         if(ixjdebug & 0x0020) {
2751                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2752                         }
2753                         j->flags.cidcw_ack = 1;
2754                 }
2755                 j->dtmf_state = 0;
2756         }
2757         j->dtmf_proc = 0;
2758
2759         return 0;
2760 }
2761
2762 /************************************************************************
2763 *
2764 * Functions to allow alaw <-> ulaw conversions.
2765 *
2766 ************************************************************************/
2767
2768 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2769 {
2770         static unsigned char table_ulaw2alaw[] =
2771         {
2772                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2773                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2774                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2775                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2776                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2777                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2778                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2779                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2780                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2781                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2782                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2783                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2784                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2785                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2786                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2787                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2788                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2789                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2790                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2791                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2792                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2793                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2794                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2795                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2796                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2797                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2798                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2799                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2800                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2801                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2802                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2803                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2804         };
2805
2806         while (len--)
2807         {
2808                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2809                 buff++;
2810         }
2811 }
2812
2813 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2814 {
2815         static unsigned char table_alaw2ulaw[] =
2816         {
2817                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2818                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2819                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2820                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2821                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2822                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2823                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2824                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2825                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2826                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2827                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2828                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2829                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2830                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2831                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2832                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2833                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2834                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2835                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2836                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2837                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2838                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2839                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2840                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2841                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2842                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2843                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2844                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2845                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2846                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2847                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2848                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2849         };
2850
2851         while (len--)
2852         {
2853                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2854                 buff++;
2855         }
2856 }
2857
2858 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2859 {
2860         unsigned long i = *ppos;
2861         IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2862
2863         DECLARE_WAITQUEUE(wait, current);
2864
2865         if (j->flags.inread)
2866                 return -EALREADY;
2867
2868         j->flags.inread = 1;
2869
2870         add_wait_queue(&j->read_q, &wait);
2871         set_current_state(TASK_INTERRUPTIBLE);
2872         mb();
2873
2874         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2875                 ++j->read_wait;
2876                 if (file_p->f_flags & O_NONBLOCK) {
2877                         set_current_state(TASK_RUNNING);
2878                         remove_wait_queue(&j->read_q, &wait);
2879                         j->flags.inread = 0;
2880                         return -EAGAIN;
2881                 }
2882                 if (!ixj_hookstate(j)) {
2883                         set_current_state(TASK_RUNNING);
2884                         remove_wait_queue(&j->read_q, &wait);
2885                         j->flags.inread = 0;
2886                         return 0;
2887                 }
2888                 interruptible_sleep_on(&j->read_q);
2889                 if (signal_pending(current)) {
2890                         set_current_state(TASK_RUNNING);
2891                         remove_wait_queue(&j->read_q, &wait);
2892                         j->flags.inread = 0;
2893                         return -EINTR;
2894                 }
2895         }
2896
2897         remove_wait_queue(&j->read_q, &wait);
2898         set_current_state(TASK_RUNNING);
2899         /* Don't ever copy more than the user asks */
2900         if(j->rec_codec == ALAW)
2901                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2902         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2903         j->read_buffer_ready = 0;
2904         if (i) {
2905                 j->flags.inread = 0;
2906                 return -EFAULT;
2907         } else {
2908                 j->flags.inread = 0;
2909                 return min(length, j->read_buffer_size);
2910         }
2911 }
2912
2913 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2914                           loff_t * ppos)
2915 {
2916         int pre_retval;
2917         ssize_t read_retval = 0;
2918         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2919
2920         pre_retval = ixj_PreRead(j, 0L);
2921         switch (pre_retval) {
2922         case NORMAL:
2923                 read_retval = ixj_read(file_p, buf, length, ppos);
2924                 ixj_PostRead(j, 0L);
2925                 break;
2926         case NOPOST:
2927                 read_retval = ixj_read(file_p, buf, length, ppos);
2928                 break;
2929         case POSTONLY:
2930                 ixj_PostRead(j, 0L);
2931                 break;
2932         default:
2933                 read_retval = pre_retval;
2934         }
2935         return read_retval;
2936 }
2937
2938 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2939 {
2940         unsigned long i = *ppos;
2941         IXJ *j = file_p->private_data;
2942
2943         DECLARE_WAITQUEUE(wait, current);
2944
2945         if (j->flags.inwrite)
2946                 return -EALREADY;
2947
2948         j->flags.inwrite = 1;
2949
2950         add_wait_queue(&j->write_q, &wait);
2951         set_current_state(TASK_INTERRUPTIBLE);
2952         mb();
2953
2954
2955         while (!j->write_buffers_empty) {
2956                 ++j->write_wait;
2957                 if (file_p->f_flags & O_NONBLOCK) {
2958                         set_current_state(TASK_RUNNING);
2959                         remove_wait_queue(&j->write_q, &wait);
2960                         j->flags.inwrite = 0;
2961                         return -EAGAIN;
2962                 }
2963                 if (!ixj_hookstate(j)) {
2964                         set_current_state(TASK_RUNNING);
2965                         remove_wait_queue(&j->write_q, &wait);
2966                         j->flags.inwrite = 0;
2967                         return 0;
2968                 }
2969                 interruptible_sleep_on(&j->write_q);
2970                 if (signal_pending(current)) {
2971                         set_current_state(TASK_RUNNING);
2972                         remove_wait_queue(&j->write_q, &wait);
2973                         j->flags.inwrite = 0;
2974                         return -EINTR;
2975                 }
2976         }
2977         set_current_state(TASK_RUNNING);
2978         remove_wait_queue(&j->write_q, &wait);
2979         if (j->write_buffer_wp + count >= j->write_buffer_end)
2980                 j->write_buffer_wp = j->write_buffer;
2981         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2982         if (i) {
2983                 j->flags.inwrite = 0;
2984                 return -EFAULT;
2985         }
2986        if(j->play_codec == ALAW)
2987                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2988         j->flags.inwrite = 0;
2989         return min(count, j->write_buffer_size);
2990 }
2991
2992 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2993 {
2994         int pre_retval;
2995         ssize_t write_retval = 0;
2996
2997         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2998
2999         pre_retval = ixj_PreWrite(j, 0L);
3000         switch (pre_retval) {
3001         case NORMAL:
3002                 write_retval = ixj_write(file_p, buf, count, ppos);
3003                 if (write_retval > 0) {
3004                         ixj_PostWrite(j, 0L);
3005                         j->write_buffer_wp += write_retval;
3006                         j->write_buffers_empty--;
3007                 }
3008                 break;
3009         case NOPOST:
3010                 write_retval = ixj_write(file_p, buf, count, ppos);
3011                 if (write_retval > 0) {
3012                         j->write_buffer_wp += write_retval;
3013                         j->write_buffers_empty--;
3014                 }
3015                 break;
3016         case POSTONLY:
3017                 ixj_PostWrite(j, 0L);
3018                 break;
3019         default:
3020                 write_retval = pre_retval;
3021         }
3022         return write_retval;
3023 }
3024
3025 static void ixj_read_frame(IXJ *j)
3026 {
3027         int cnt, dly;
3028
3029         if (j->read_buffer) {
3030                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3031                         if (!(cnt % 16) && !IsRxReady(j)) {
3032                                 dly = 0;
3033                                 while (!IsRxReady(j)) {
3034                                         if (dly++ > 5) {
3035                                                 dly = 0;
3036                                                 break;
3037                                         }
3038                                         udelay(10);
3039                                 }
3040                         }
3041                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
3042                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3043                                 inb_p(j->DSPbase + 0x0E);
3044                                 inb_p(j->DSPbase + 0x0F);
3045                         }
3046                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
3047                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
3048                 }
3049                 ++j->framesread;
3050                 if (j->intercom != -1) {
3051                         if (IsTxReady(get_ixj(j->intercom))) {
3052                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3053                                         if (!(cnt % 16) && !IsTxReady(j)) {
3054                                                 dly = 0;
3055                                                 while (!IsTxReady(j)) {
3056                                                         if (dly++ > 5) {
3057                                                                 dly = 0;
3058                                                                 break;
3059                                                         }
3060                                                         udelay(10);
3061                                                 }
3062                                         }
3063                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
3064                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
3065                                 }
3066                                 get_ixj(j->intercom)->frameswritten++;
3067                         }
3068                 } else {
3069                         j->read_buffer_ready = 1;
3070                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
3071
3072                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3073
3074                         if(j->ixj_signals[SIG_READ_READY])
3075                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
3076                 }
3077         }
3078 }
3079
3080 static short fsk[][6][20] =
3081 {
3082         {
3083                 {
3084                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
3085                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
3086                 },
3087                 {
3088                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
3089                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
3090                 },
3091                 {
3092                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
3093                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
3094                 },
3095                 {
3096                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
3097                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
3098                 },
3099                 {
3100                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3101                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3102                 },
3103                 {
3104                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3105                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3106                 }
3107         },
3108         {
3109                 {
3110                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3111                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3112                 },
3113                 {
3114                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3115                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3116                 },
3117                 {
3118                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3119                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3120                 },
3121                 {
3122                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3123                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3124                 },
3125                 {
3126                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3127                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3128                 },
3129                 {
3130                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3131                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3132                 }
3133         }
3134 };
3135
3136
3137 static void ixj_write_cid_bit(IXJ *j, int bit)
3138 {
3139         while (j->fskcnt < 20) {
3140                 if(j->fskdcnt < (j->fsksize - 1))
3141                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3142
3143                 j->fskcnt += 3;
3144         }
3145         j->fskcnt %= 20;
3146
3147         if (!bit)
3148                 j->fskz++;
3149         if (j->fskz >= 6)
3150                 j->fskz = 0;
3151
3152 }
3153
3154 static void ixj_write_cid_byte(IXJ *j, char byte)
3155 {
3156         IXJ_CBYTE cb;
3157
3158                 cb.cbyte = byte;
3159                 ixj_write_cid_bit(j, 0);
3160                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3161                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3162                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3163                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3164                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3165                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3166                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3167                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3168                 ixj_write_cid_bit(j, 1);
3169 }
3170
3171 static void ixj_write_cid_seize(IXJ *j)
3172 {
3173         int cnt;
3174
3175         for (cnt = 0; cnt < 150; cnt++) {
3176                 ixj_write_cid_bit(j, 0);
3177                 ixj_write_cid_bit(j, 1);
3178         }
3179         for (cnt = 0; cnt < 180; cnt++) {
3180                 ixj_write_cid_bit(j, 1);
3181         }
3182 }
3183
3184 static void ixj_write_cidcw_seize(IXJ *j)
3185 {
3186         int cnt;
3187
3188         for (cnt = 0; cnt < 80; cnt++) {
3189                 ixj_write_cid_bit(j, 1);
3190         }
3191 }
3192
3193 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3194 {
3195         int cnt;
3196
3197         for (cnt = 0; cnt < strlen(s); cnt++) {
3198                 ixj_write_cid_byte(j, s[cnt]);
3199                 checksum = (checksum + s[cnt]);
3200         }
3201         return checksum;
3202 }
3203
3204 static void ixj_pad_fsk(IXJ *j, int pad)
3205 {
3206         int cnt;
3207
3208         for (cnt = 0; cnt < pad; cnt++) {
3209                 if(j->fskdcnt < (j->fsksize - 1))
3210                         j->fskdata[j->fskdcnt++] = 0x0000;
3211         }
3212         for (cnt = 0; cnt < 720; cnt++) {
3213                 if(j->fskdcnt < (j->fsksize - 1))
3214                         j->fskdata[j->fskdcnt++] = 0x0000;
3215         }
3216 }
3217
3218 static void ixj_pre_cid(IXJ *j)
3219 {
3220         j->cid_play_codec = j->play_codec;
3221         j->cid_play_frame_size = j->play_frame_size;
3222         j->cid_play_volume = get_play_volume(j);
3223         j->cid_play_flag = j->flags.playing;
3224
3225         j->cid_rec_codec = j->rec_codec;
3226         j->cid_rec_volume = get_rec_volume(j);
3227         j->cid_rec_flag = j->flags.recording;
3228
3229         j->cid_play_aec_level = j->aec_level;
3230
3231         switch(j->baseframe.low) {
3232                 case 0xA0:
3233                         j->cid_base_frame_size = 20;
3234                         break;
3235                 case 0x50:
3236                         j->cid_base_frame_size = 10;
3237                         break;
3238                 case 0xF0:
3239                         j->cid_base_frame_size = 30;
3240                         break;
3241         }
3242
3243         ixj_play_stop(j);
3244         ixj_cpt_stop(j);
3245
3246         j->flags.cidplay = 1;
3247
3248         set_base_frame(j, 30);
3249         set_play_codec(j, LINEAR16);
3250         set_play_volume(j, 0x1B);
3251         ixj_play_start(j);
3252 }
3253
3254 static void ixj_post_cid(IXJ *j)
3255 {
3256         ixj_play_stop(j);
3257
3258         if(j->cidsize > 5000) {
3259                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3260         }
3261         j->flags.cidplay = 0;
3262         if(ixjdebug & 0x0200) {
3263                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3264         }
3265
3266         ixj_fsk_free(j);
3267
3268         j->fskdcnt = 0;
3269         set_base_frame(j, j->cid_base_frame_size);
3270         set_play_codec(j, j->cid_play_codec);
3271         ixj_aec_start(j, j->cid_play_aec_level);
3272         set_play_volume(j, j->cid_play_volume);
3273
3274         set_rec_codec(j, j->cid_rec_codec);
3275         set_rec_volume(j, j->cid_rec_volume);
3276
3277         if(j->cid_rec_flag)
3278                 ixj_record_start(j);
3279
3280         if(j->cid_play_flag)
3281                 ixj_play_start(j);
3282
3283         if(j->cid_play_flag) {
3284                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3285         }
3286 }
3287
3288 static void ixj_write_cid(IXJ *j)
3289 {
3290         char sdmf1[50];
3291         char sdmf2[50];
3292         char sdmf3[80];
3293         char mdmflen, len1, len2, len3;
3294         int pad;
3295
3296         int checksum = 0;
3297
3298         if (j->dsp.low == 0x20 || j->flags.cidplay)
3299                 return;
3300
3301         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3302         j->cidsize = j->cidcnt = 0;
3303
3304         ixj_fsk_alloc(j);
3305
3306         strcpy(sdmf1, j->cid_send.month);
3307         strcat(sdmf1, j->cid_send.day);
3308         strcat(sdmf1, j->cid_send.hour);
3309         strcat(sdmf1, j->cid_send.min);
3310         strcpy(sdmf2, j->cid_send.number);
3311         strcpy(sdmf3, j->cid_send.name);
3312
3313         len1 = strlen(sdmf1);
3314         len2 = strlen(sdmf2);
3315         len3 = strlen(sdmf3);
3316         mdmflen = len1 + len2 + len3 + 6;
3317
3318         while(1){
3319                 ixj_write_cid_seize(j);
3320
3321                 ixj_write_cid_byte(j, 0x80);
3322                 checksum = 0x80;
3323                 ixj_write_cid_byte(j, mdmflen);
3324                 checksum = checksum + mdmflen;
3325
3326                 ixj_write_cid_byte(j, 0x01);
3327                 checksum = checksum + 0x01;
3328                 ixj_write_cid_byte(j, len1);
3329                 checksum = checksum + len1;
3330                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3331                 if(ixj_hookstate(j) & 1)
3332                         break;
3333
3334                 ixj_write_cid_byte(j, 0x02);
3335                 checksum = checksum + 0x02;
3336                 ixj_write_cid_byte(j, len2);
3337                 checksum = checksum + len2;
3338                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3339                 if(ixj_hookstate(j) & 1)
3340                         break;
3341
3342                 ixj_write_cid_byte(j, 0x07);
3343                 checksum = checksum + 0x07;
3344                 ixj_write_cid_byte(j, len3);
3345                 checksum = checksum + len3;
3346                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3347                 if(ixj_hookstate(j) & 1)
3348                         break;
3349
3350                 checksum %= 256;
3351                 checksum ^= 0xFF;
3352                 checksum += 1;
3353
3354                 ixj_write_cid_byte(j, (char) checksum);
3355
3356                 pad = j->fskdcnt % 240;
3357                 if (pad) {
3358                         pad = 240 - pad;
3359                 }
3360                 ixj_pad_fsk(j, pad);
3361                 break;
3362         }
3363
3364         ixj_write_frame(j);
3365 }
3366
3367 static void ixj_write_cidcw(IXJ *j)
3368 {
3369         IXJ_TONE ti;
3370
3371         char sdmf1[50];
3372         char sdmf2[50];
3373         char sdmf3[80];
3374         char mdmflen, len1, len2, len3;
3375         int pad;
3376
3377         int checksum = 0;
3378
3379         if (j->dsp.low == 0x20 || j->flags.cidplay)
3380                 return;
3381
3382         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3383         j->cidsize = j->cidcnt = 0;
3384
3385         ixj_fsk_alloc(j);
3386
3387         j->flags.cidcw_ack = 0;
3388
3389         ti.tone_index = 23;
3390         ti.gain0 = 1;
3391         ti.freq0 = hz440;
3392         ti.gain1 = 0;
3393         ti.freq1 = 0;
3394         ixj_init_tone(j, &ti);
3395
3396         ixj_set_tone_on(1500, j);
3397         ixj_set_tone_off(32, j);
3398         if(ixjdebug & 0x0200) {
3399                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3400         }
3401         ixj_play_tone(j, 23);
3402
3403         clear_bit(j->board, &j->busyflags);
3404         while(j->tone_state) {
3405                 set_current_state(TASK_INTERRUPTIBLE);
3406                 schedule_timeout(1);
3407         }
3408         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3409                 set_current_state(TASK_INTERRUPTIBLE);
3410                 schedule_timeout(1);
3411         }
3412         if(ixjdebug & 0x0200) {
3413                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3414         }
3415
3416         ti.tone_index = 24;
3417         ti.gain0 = 1;
3418         ti.freq0 = hz2130;
3419         ti.gain1 = 0;
3420         ti.freq1 = hz2750;
3421         ixj_init_tone(j, &ti);
3422
3423         ixj_set_tone_off(10, j);
3424         ixj_set_tone_on(600, j);
3425         if(ixjdebug & 0x0200) {
3426                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3427         }
3428         ixj_play_tone(j, 24);
3429
3430         clear_bit(j->board, &j->busyflags);
3431         while(j->tone_state) {
3432                 set_current_state(TASK_INTERRUPTIBLE);
3433                 schedule_timeout(1);
3434         }
3435         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3436                 set_current_state(TASK_INTERRUPTIBLE);
3437                 schedule_timeout(1);
3438         }
3439         if(ixjdebug & 0x0200) {
3440                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3441         }
3442
3443         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3444
3445         clear_bit(j->board, &j->busyflags);
3446         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3447                 set_current_state(TASK_INTERRUPTIBLE);
3448                 schedule_timeout(1);
3449         }
3450         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3451                 set_current_state(TASK_INTERRUPTIBLE);
3452                 schedule_timeout(1);
3453         }
3454         j->cidcw_wait = 0;
3455         if(!j->flags.cidcw_ack) {
3456                 if(ixjdebug & 0x0200) {
3457                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3458                 }
3459                 ixj_post_cid(j);
3460                 if(j->cid_play_flag) {
3461                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3462                 }
3463                 return;
3464         } else {
3465                 ixj_pre_cid(j);
3466         }
3467         j->flags.cidcw_ack = 0;
3468         strcpy(sdmf1, j->cid_send.month);
3469         strcat(sdmf1, j->cid_send.day);
3470         strcat(sdmf1, j->cid_send.hour);
3471         strcat(sdmf1, j->cid_send.min);
3472         strcpy(sdmf2, j->cid_send.number);
3473         strcpy(sdmf3, j->cid_send.name);
3474
3475         len1 = strlen(sdmf1);
3476         len2 = strlen(sdmf2);
3477         len3 = strlen(sdmf3);
3478         mdmflen = len1 + len2 + len3 + 6;
3479
3480         ixj_write_cidcw_seize(j);
3481
3482         ixj_write_cid_byte(j, 0x80);
3483         checksum = 0x80;
3484         ixj_write_cid_byte(j, mdmflen);
3485         checksum = checksum + mdmflen;
3486
3487         ixj_write_cid_byte(j, 0x01);
3488         checksum = checksum + 0x01;
3489         ixj_write_cid_byte(j, len1);
3490         checksum = checksum + len1;
3491         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3492
3493         ixj_write_cid_byte(j, 0x02);
3494         checksum = checksum + 0x02;
3495         ixj_write_cid_byte(j, len2);
3496         checksum = checksum + len2;
3497         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3498
3499         ixj_write_cid_byte(j, 0x07);
3500         checksum = checksum + 0x07;
3501         ixj_write_cid_byte(j, len3);
3502         checksum = checksum + len3;
3503         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3504
3505         checksum %= 256;
3506         checksum ^= 0xFF;
3507         checksum += 1;
3508
3509         ixj_write_cid_byte(j, (char) checksum);
3510
3511         pad = j->fskdcnt % 240;
3512         if (pad) {
3513                 pad = 240 - pad;
3514         }
3515         ixj_pad_fsk(j, pad);
3516         if(ixjdebug & 0x0200) {
3517                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3518         }
3519 }
3520
3521 static void ixj_write_vmwi(IXJ *j, int msg)
3522 {
3523         char mdmflen;
3524         int pad;
3525
3526         int checksum = 0;
3527
3528         if (j->dsp.low == 0x20 || j->flags.cidplay)
3529                 return;
3530
3531         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3532         j->cidsize = j->cidcnt = 0;
3533
3534         ixj_fsk_alloc(j);
3535
3536         mdmflen = 3;
3537
3538         if (j->port == PORT_POTS)
3539                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3540
3541         ixj_write_cid_seize(j);
3542
3543         ixj_write_cid_byte(j, 0x82);
3544         checksum = 0x82;
3545         ixj_write_cid_byte(j, mdmflen);
3546         checksum = checksum + mdmflen;
3547
3548         ixj_write_cid_byte(j, 0x0B);
3549         checksum = checksum + 0x0B;
3550         ixj_write_cid_byte(j, 1);
3551         checksum = checksum + 1;
3552
3553         if(msg) {
3554                 ixj_write_cid_byte(j, 0xFF);
3555                 checksum = checksum + 0xFF;
3556         }
3557         else {
3558                 ixj_write_cid_byte(j, 0x00);
3559                 checksum = checksum + 0x00;
3560         }
3561
3562         checksum %= 256;
3563         checksum ^= 0xFF;
3564         checksum += 1;
3565
3566         ixj_write_cid_byte(j, (char) checksum);
3567
3568         pad = j->fskdcnt % 240;
3569         if (pad) {
3570                 pad = 240 - pad;
3571         }
3572         ixj_pad_fsk(j, pad);
3573 }
3574
3575 static void ixj_write_frame(IXJ *j)
3576 {
3577         int cnt, frame_count, dly;
3578         IXJ_WORD dat;
3579         BYTES blankword;
3580
3581         frame_count = 0;
3582         if(j->flags.cidplay) {
3583                 for(cnt = 0; cnt < 480; cnt++) {
3584                         if (!(cnt % 16) && !IsTxReady(j)) {
3585                                 dly = 0;
3586                                 while (!IsTxReady(j)) {
3587                                         if (dly++ > 5) {
3588                                                 dly = 0;
3589                                                 break;
3590                                         }
3591                                         udelay(10);
3592                                 }
3593                         }
3594                         dat.word = j->fskdata[j->cidcnt++];
3595                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3596                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3597                         cnt++;
3598                 }
3599                 if(j->cidcnt >= j->fskdcnt) {
3600                         ixj_post_cid(j);
3601                 }
3602                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3603                    and there is real audio data in the buffer, we need to throw it away because
3604                    we just used it's time slot */
3605                 if (j->write_buffer_rp > j->write_buffer_wp) {
3606                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3607                         if (j->write_buffer_rp >= j->write_buffer_end) {
3608                                 j->write_buffer_rp = j->write_buffer;
3609                         }
3610                         j->write_buffers_empty++;
3611                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3612
3613                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3614                 }
3615         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3616                 if (j->write_buffer_wp > j->write_buffer_rp) {
3617                         frame_count =
3618                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3619                 }
3620                 if (j->write_buffer_rp > j->write_buffer_wp) {
3621                         frame_count =
3622                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3623                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3624                 }
3625                 if (frame_count >= 1) {
3626                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3627                                 switch (j->play_mode) {
3628                                 case PLAYBACK_MODE_ULAW:
3629                                 case PLAYBACK_MODE_ALAW:
3630                                         blankword.low = blankword.high = 0xFF;
3631                                         break;
3632                                 case PLAYBACK_MODE_8LINEAR:
3633                                 case PLAYBACK_MODE_16LINEAR:
3634                                         blankword.low = blankword.high = 0x00;
3635                                         break;
3636                                 case PLAYBACK_MODE_8LINEAR_WSS:
3637                                         blankword.low = blankword.high = 0x80;
3638                                         break;
3639                                 }
3640                                 for (cnt = 0; cnt < 16; cnt++) {
3641                                         if (!(cnt % 16) && !IsTxReady(j)) {
3642                                                 dly = 0;
3643                                                 while (!IsTxReady(j)) {
3644                                                         if (dly++ > 5) {
3645                                                                 dly = 0;
3646                                                                 break;
3647                                                         }
3648                                                         udelay(10);
3649                                                 }
3650                                         }
3651                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3652                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3653                                 }
3654                                 j->flags.play_first_frame = 0;
3655                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3656                                 for (cnt = 0; cnt < 24; cnt++) {
3657                                         if(cnt == 12) {
3658                                                 blankword.low = 0x02;
3659                                                 blankword.high = 0x00;
3660                                         }
3661                                         else {
3662                                                 blankword.low = blankword.high = 0x00;
3663                                         }
3664                                         if (!(cnt % 16) && !IsTxReady(j)) {
3665                                                 dly = 0;
3666                                                 while (!IsTxReady(j)) {
3667                                                         if (dly++ > 5) {
3668                                                                 dly = 0;
3669                                                                 break;
3670                                                         }
3671                                                         udelay(10);
3672                                                 }
3673                                         }
3674                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3675                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3676                                 }
3677                                 j->flags.play_first_frame = 0;
3678                         }
3679                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3680                                 if (!(cnt % 16) && !IsTxReady(j)) {
3681                                         dly = 0;
3682                                         while (!IsTxReady(j)) {
3683                                                 if (dly++ > 5) {
3684                                                         dly = 0;
3685                                                         break;
3686                                                 }
3687                                                 udelay(10);
3688                                         }
3689                                 }
3690                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3691                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3692                                         if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3693                                            j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3694                                            j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3695                                            j->write_buffer_rp + cnt + 9 == 0) {
3696                                         /* someone is trying to write silence lets make this a type 0 frame. */
3697                                                 outb_p(0x00, j->DSPbase + 0x0C);
3698                                                 outb_p(0x00, j->DSPbase + 0x0D);
3699                                         } else {
3700                                         /* so all other frames are type 1. */
3701                                                 outb_p(0x01, j->DSPbase + 0x0C);
3702                                                 outb_p(0x00, j->DSPbase + 0x0D);
3703                                         }
3704                                 }
3705                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3706                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3707                                 *(j->write_buffer_rp + cnt) = 0;
3708                                 *(j->write_buffer_rp + cnt + 1) = 0;
3709                         }
3710                         j->write_buffer_rp += j->play_frame_size * 2;
3711                         if (j->write_buffer_rp >= j->write_buffer_end) {
3712                                 j->write_buffer_rp = j->write_buffer;
3713                         }
3714                         j->write_buffers_empty++;
3715                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3716
3717                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3718
3719                         ++j->frameswritten;
3720                 }
3721         } else {
3722                 j->drybuffer++;
3723         }
3724         if(j->ixj_signals[SIG_WRITE_READY]) {
3725                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3726         }
3727 }
3728
3729 static int idle(IXJ *j)
3730 {
3731         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3732
3733                 return 0;
3734
3735         if (j->ssr.high || j->ssr.low) {
3736                 return 0;
3737         } else {
3738                 j->play_mode = -1;
3739                 j->flags.playing = 0;
3740                 j->rec_mode = -1;
3741                 j->flags.recording = 0;
3742                 return 1;
3743         }
3744 }
3745
3746 static int set_base_frame(IXJ *j, int size)
3747 {
3748         unsigned short cmd;
3749         int cnt;
3750
3751         idle(j);
3752         j->cid_play_aec_level = j->aec_level;
3753         aec_stop(j);
3754         for (cnt = 0; cnt < 10; cnt++) {
3755                 if (idle(j))
3756                         break;
3757         }
3758         if (j->ssr.high || j->ssr.low)
3759                 return -1;
3760         if (j->dsp.low != 0x20) {
3761                 switch (size) {
3762                 case 30:
3763                         cmd = 0x07F0;
3764                         /* Set Base Frame Size to 240 pg9-10 8021 */
3765                         break;
3766                 case 20:
3767                         cmd = 0x07A0;
3768                         /* Set Base Frame Size to 160 pg9-10 8021 */
3769                         break;
3770                 case 10:
3771                         cmd = 0x0750;
3772                         /* Set Base Frame Size to 80 pg9-10 8021 */
3773                         break;
3774                 default:
3775                         return -1;
3776                 }
3777         } else {
3778                 if (size == 30)
3779                         return size;
3780                 else
3781                         return -1;
3782         }
3783         if (ixj_WriteDSPCommand(cmd, j)) {
3784                 j->baseframe.high = j->baseframe.low = 0xFF;
3785                 return -1;
3786         } else {
3787                 j->baseframe.high = j->ssr.high;
3788                 j->baseframe.low = j->ssr.low;
3789                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3790                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3791                         return -1;
3792                 }
3793         }
3794         ixj_aec_start(j, j->cid_play_aec_level);
3795         return size;
3796 }
3797
3798 static int set_rec_codec(IXJ *j, int rate)
3799 {
3800         int retval = 0;
3801
3802         j->rec_codec = rate;
3803
3804         switch (rate) {
3805         case G723_63:
3806                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3807                         j->rec_frame_size = 12;
3808                         j->rec_mode = 0;
3809                 } else {
3810                         retval = 1;
3811                 }
3812                 break;
3813         case G723_53:
3814                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3815                         j->rec_frame_size = 10;
3816                         j->rec_mode = 0;
3817                 } else {
3818                         retval = 1;
3819                 }
3820                 break;
3821         case TS85:
3822                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3823                         j->rec_frame_size = 16;
3824                         j->rec_mode = 0;
3825                 } else {
3826                         retval = 1;
3827                 }
3828                 break;
3829         case TS48:
3830                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3831                         j->rec_frame_size = 9;
3832                         j->rec_mode = 0;
3833                 } else {
3834                         retval = 1;
3835                 }
3836                 break;
3837         case TS41:
3838                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3839                         j->rec_frame_size = 8;
3840                         j->rec_mode = 0;
3841                 } else {
3842                         retval = 1;
3843                 }
3844                 break;
3845         case G728:
3846                 if (j->dsp.low != 0x20) {
3847                         j->rec_frame_size = 48;
3848                         j->rec_mode = 0;
3849                 } else {
3850                         retval = 1;
3851                 }
3852                 break;
3853         case G729:
3854                 if (j->dsp.low != 0x20) {
3855                         if (!j->flags.g729_loaded) {
3856                                 retval = 1;
3857                                 break;
3858                         }
3859                         switch (j->baseframe.low) {
3860                         case 0xA0:
3861                                 j->rec_frame_size = 10;
3862                                 break;
3863                         case 0x50:
3864                                 j->rec_frame_size = 5;
3865                                 break;
3866                         default:
3867                                 j->rec_frame_size = 15;
3868                                 break;
3869                         }
3870                         j->rec_mode = 0;
3871                 } else {
3872                         retval = 1;
3873                 }
3874                 break;
3875         case G729B:
3876                 if (j->dsp.low != 0x20) {
3877                         if (!j->flags.g729_loaded) {
3878                                 retval = 1;
3879                                 break;
3880                         }
3881                         switch (j->baseframe.low) {
3882                         case 0xA0:
3883                                 j->rec_frame_size = 12;
3884                                 break;
3885                         case 0x50:
3886                                 j->rec_frame_size = 6;
3887                                 break;
3888                         default:
3889                                 j->rec_frame_size = 18;
3890                                 break;
3891                         }
3892                         j->rec_mode = 0;
3893                 } else {
3894                         retval = 1;
3895                 }
3896                 break;
3897         case ULAW:
3898                 switch (j->baseframe.low) {
3899                 case 0xA0:
3900                         j->rec_frame_size = 80;
3901                         break;
3902                 case 0x50:
3903                         j->rec_frame_size = 40;
3904                         break;
3905                 default:
3906                         j->rec_frame_size = 120;
3907                         break;
3908                 }
3909                 j->rec_mode = 4;
3910                 break;
3911         case ALAW:
3912                 switch (j->baseframe.low) {
3913                 case 0xA0:
3914                         j->rec_frame_size = 80;
3915                         break;
3916                 case 0x50:
3917                         j->rec_frame_size = 40;
3918                         break;
3919                 default:
3920                         j->rec_frame_size = 120;
3921                         break;
3922                 }
3923                 j->rec_mode = 4;
3924                 break;
3925         case LINEAR16:
3926                 switch (j->baseframe.low) {
3927                 case 0xA0:
3928                         j->rec_frame_size = 160;
3929                         break;
3930                 case 0x50:
3931                         j->rec_frame_size = 80;
3932                         break;
3933                 default:
3934                         j->rec_frame_size = 240;
3935                         break;
3936                 }
3937                 j->rec_mode = 5;
3938                 break;
3939         case LINEAR8:
3940                 switch (j->baseframe.low) {
3941                 case 0xA0:
3942                         j->rec_frame_size = 80;
3943                         break;
3944                 case 0x50:
3945                         j->rec_frame_size = 40;
3946                         break;
3947                 default:
3948                         j->rec_frame_size = 120;
3949                         break;
3950                 }
3951                 j->rec_mode = 6;
3952                 break;
3953         case WSS:
3954                 switch (j->baseframe.low) {
3955                 case 0xA0:
3956                         j->rec_frame_size = 80;
3957                         break;
3958                 case 0x50:
3959                         j->rec_frame_size = 40;
3960                         break;
3961                 default:
3962                         j->rec_frame_size = 120;
3963                         break;
3964                 }
3965                 j->rec_mode = 7;
3966                 break;
3967         default:
3968                 j->rec_frame_size = 0;
3969                 j->rec_mode = -1;
3970                 if (j->read_buffer) {
3971                         kfree(j->read_buffer);
3972                         j->read_buffer = NULL;
3973                         j->read_buffer_size = 0;
3974                 }
3975                 retval = 1;
3976                 break;
3977         }
3978         return retval;
3979 }
3980
3981 static int ixj_record_start(IXJ *j)
3982 {
3983         unsigned short cmd = 0x0000;
3984
3985         if (j->read_buffer) {
3986                 ixj_record_stop(j);
3987         }
3988         j->flags.recording = 1;
3989         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3990
3991         if(ixjdebug & 0x0002)
3992                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3993
3994         if (!j->rec_mode) {
3995                 switch (j->rec_codec) {
3996                 case G723_63:
3997                         cmd = 0x5131;
3998                         break;
3999                 case G723_53:
4000                         cmd = 0x5132;
4001                         break;
4002                 case TS85:
4003                         cmd = 0x5130;   /* TrueSpeech 8.5 */
4004
4005                         break;
4006                 case TS48:
4007                         cmd = 0x5133;   /* TrueSpeech 4.8 */
4008
4009                         break;
4010                 case TS41:
4011                         cmd = 0x5134;   /* TrueSpeech 4.1 */
4012
4013                         break;
4014                 case G728:
4015                         cmd = 0x5135;
4016                         break;
4017                 case G729:
4018                 case G729B:
4019                         cmd = 0x5136;
4020                         break;
4021                 default:
4022                         return 1;
4023                 }
4024                 if (ixj_WriteDSPCommand(cmd, j))
4025                         return -1;
4026         }
4027         if (!j->read_buffer) {
4028                 if (!j->read_buffer)
4029                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
4030                 if (!j->read_buffer) {
4031                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
4032                         return -ENOMEM;
4033                 }
4034         }
4035         j->read_buffer_size = j->rec_frame_size * 2;
4036
4037         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
4038
4039                 return -1;
4040
4041         switch (j->rec_mode) {
4042         case 0:
4043                 cmd = 0x1C03;   /* Record C1 */
4044
4045                 break;
4046         case 4:
4047                 if (j->ver.low == 0x12) {
4048                         cmd = 0x1E03;   /* Record C1 */
4049
4050                 } else {
4051                         cmd = 0x1E01;   /* Record C1 */
4052
4053                 }
4054                 break;
4055         case 5:
4056                 if (j->ver.low == 0x12) {
4057                         cmd = 0x1E83;   /* Record C1 */
4058
4059                 } else {
4060                         cmd = 0x1E81;   /* Record C1 */
4061
4062                 }
4063                 break;
4064         case 6:
4065                 if (j->ver.low == 0x12) {
4066                         cmd = 0x1F03;   /* Record C1 */
4067
4068                 } else {
4069                         cmd = 0x1F01;   /* Record C1 */
4070
4071                 }
4072                 break;
4073         case 7:
4074                 if (j->ver.low == 0x12) {
4075                         cmd = 0x1F83;   /* Record C1 */
4076                 } else {
4077                         cmd = 0x1F81;   /* Record C1 */
4078                 }
4079                 break;
4080         }
4081         if (ixj_WriteDSPCommand(cmd, j))
4082                 return -1;
4083
4084         if (j->flags.playing) {
4085                 ixj_aec_start(j, j->aec_level);
4086         }
4087         return 0;
4088 }
4089
4090 static void ixj_record_stop(IXJ *j)
4091 {
4092         if(ixjdebug & 0x0002)
4093                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
4094
4095         if (j->read_buffer) {
4096                 kfree(j->read_buffer);
4097                 j->read_buffer = NULL;
4098                 j->read_buffer_size = 0;
4099         }
4100         if (j->rec_mode > -1) {
4101                 ixj_WriteDSPCommand(0x5120, j);
4102                 j->rec_mode = -1;
4103         }
4104         j->flags.recording = 0;
4105 }
4106 static void ixj_vad(IXJ *j, int arg)
4107 {
4108         if (arg)
4109                 ixj_WriteDSPCommand(0x513F, j);
4110         else
4111                 ixj_WriteDSPCommand(0x513E, j);
4112 }
4113
4114 static void set_rec_depth(IXJ *j, int depth)
4115 {
4116         if (depth > 60)
4117                 depth = 60;
4118         if (depth < 0)
4119                 depth = 0;
4120         ixj_WriteDSPCommand(0x5180 + depth, j);
4121 }
4122
4123 static void set_dtmf_prescale(IXJ *j, int volume)
4124 {
4125         ixj_WriteDSPCommand(0xCF07, j);
4126         ixj_WriteDSPCommand(volume, j);
4127 }
4128
4129 static int get_dtmf_prescale(IXJ *j)
4130 {
4131         ixj_WriteDSPCommand(0xCF05, j);
4132         return j->ssr.high << 8 | j->ssr.low;
4133 }
4134
4135 static void set_rec_volume(IXJ *j, int volume)
4136 {
4137         if(j->aec_level == AEC_AGC) {
4138                 if (ixjdebug & 0x0002)
4139                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4140                 ixj_WriteDSPCommand(0xCF96, j);
4141                 ixj_WriteDSPCommand(volume, j);
4142         } else {
4143                 if (ixjdebug & 0x0002)
4144                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4145                 ixj_WriteDSPCommand(0xCF03, j);
4146                 ixj_WriteDSPCommand(volume, j);
4147         }
4148 }
4149
4150 static int set_rec_volume_linear(IXJ *j, int volume)
4151 {
4152         int newvolume, dsprecmax;
4153
4154         if (ixjdebug & 0x0002)
4155                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4156         if(volume > 100 || volume < 0) {
4157           return -1;
4158         }
4159
4160         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4161         switch (j->cardtype) {
4162         case QTI_PHONEJACK:
4163                 dsprecmax = 0x440;
4164                 break;
4165         case QTI_LINEJACK:
4166                 dsprecmax = 0x180;
4167                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4168                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4169                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4170                 break;
4171         case QTI_PHONEJACK_LITE:
4172                 dsprecmax = 0x4C0;
4173                 break;
4174         case QTI_PHONEJACK_PCI:
4175                 dsprecmax = 0x100;
4176                 break;
4177         case QTI_PHONECARD:
4178                 dsprecmax = 0x400;
4179                 break;
4180         default:
4181                 return -1;
4182         }
4183         newvolume = (dsprecmax * volume) / 100;
4184         set_rec_volume(j, newvolume);
4185         return 0;
4186 }
4187
4188 static int get_rec_volume(IXJ *j)
4189 {
4190         if(j->aec_level == AEC_AGC) {
4191                 if (ixjdebug & 0x0002)
4192                         printk(KERN_INFO "Getting AGC Threshold\n");
4193                 ixj_WriteDSPCommand(0xCF86, j);
4194                 if (ixjdebug & 0x0002)
4195                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4196                 return j->ssr.high << 8 | j->ssr.low;
4197         } else {
4198                 if (ixjdebug & 0x0002)
4199                         printk(KERN_INFO "Getting Record Volume\n");
4200                 ixj_WriteDSPCommand(0xCF01, j);
4201                 return j->ssr.high << 8 | j->ssr.low;
4202         }
4203 }
4204
4205 static int get_rec_volume_linear(IXJ *j)
4206 {
4207         int volume, newvolume, dsprecmax;
4208
4209         switch (j->cardtype) {
4210         case QTI_PHONEJACK:
4211                 dsprecmax = 0x440;
4212                 break;
4213         case QTI_LINEJACK:
4214                 dsprecmax = 0x180;
4215                 break;
4216         case QTI_PHONEJACK_LITE:
4217                 dsprecmax = 0x4C0;
4218                 break;
4219         case QTI_PHONEJACK_PCI:
4220                 dsprecmax = 0x100;
4221                 break;
4222         case QTI_PHONECARD:
4223                 dsprecmax = 0x400;
4224                 break;
4225         default:
4226                 return -1;
4227         }
4228         volume = get_rec_volume(j);
4229         newvolume = (volume * 100) / dsprecmax;
4230         if(newvolume > 100)
4231                 newvolume = 100;
4232         return newvolume;
4233 }
4234
4235 static int get_rec_level(IXJ *j)
4236 {
4237         int retval;
4238
4239         ixj_WriteDSPCommand(0xCF88, j);
4240
4241         retval = j->ssr.high << 8 | j->ssr.low;
4242         retval = (retval * 256) / 240;
4243         return retval;
4244 }
4245
4246 static void ixj_aec_start(IXJ *j, int level)
4247 {
4248         j->aec_level = level;
4249         if (ixjdebug & 0x0002)
4250                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4251         if (!level) {
4252                 aec_stop(j);
4253         } else {
4254                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4255                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4256
4257                         ixj_WriteDSPCommand(0x0300, j);
4258                 }
4259                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4260
4261                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4262
4263                 switch (level) {
4264                 case AEC_LOW:
4265                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4266
4267                         ixj_WriteDSPCommand(0xE011, j);
4268                         ixj_WriteDSPCommand(0xFFFF, j);
4269
4270                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4271                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4272
4273                         break;
4274
4275                 case AEC_MED:
4276                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4277
4278                         ixj_WriteDSPCommand(0xE011, j);
4279                         ixj_WriteDSPCommand(0x0080, j);
4280
4281                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4282                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4283
4284                         break;
4285
4286                 case AEC_HIGH:
4287                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4288
4289                         ixj_WriteDSPCommand(0xE011, j);
4290                         ixj_WriteDSPCommand(0x0080, j);
4291
4292                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4293                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4294
4295                         break;
4296
4297                 case AEC_AGC:
4298                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4299                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4300
4301                         ixj_WriteDSPCommand(0xE011, j);
4302                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4303
4304                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4305
4306                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4307                                 ixj_WriteDSPCommand(0x0224, j);
4308                         else
4309                                 ixj_WriteDSPCommand(0x1224, j);
4310
4311                         ixj_WriteDSPCommand(0xE014, j);
4312                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4313
4314                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4315
4316                         /* Now we can set the AGC initial parameters and turn it on */
4317                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4318                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4319
4320                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4321                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4322
4323                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4324                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4325
4326                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4327                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4328
4329                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4330                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4331
4332                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4333                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4334
4335                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4336                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4337
4338                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4339                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4340
4341                         break;
4342
4343                 case AEC_AUTO:
4344                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4345
4346                         ixj_WriteDSPCommand(0xE011, j);
4347                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4348
4349                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4350
4351                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4352                                 ixj_WriteDSPCommand(0x0224, j);
4353                         else
4354                                 ixj_WriteDSPCommand(0x1224, j);
4355
4356                         ixj_WriteDSPCommand(0xE014, j);
4357                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4358
4359                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4360
4361                         break;
4362                 }
4363         }
4364 }
4365
4366 static void aec_stop(IXJ *j)
4367 {
4368         j->aec_level = AEC_OFF;
4369         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4370                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4371
4372                 ixj_WriteDSPCommand(0x0700, j);
4373         }
4374         if (j->play_mode != -1 && j->rec_mode != -1)
4375         {
4376                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4377         }
4378 }
4379
4380 static int set_play_codec(IXJ *j, int rate)
4381 {
4382         int retval = 0;
4383
4384         j->play_codec = rate;
4385
4386         switch (rate) {
4387         case G723_63:
4388                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4389                         j->play_frame_size = 12;
4390                         j->play_mode = 0;
4391                 } else {
4392                         retval = 1;
4393                 }
4394                 break;
4395         case G723_53:
4396                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4397                         j->play_frame_size = 10;
4398                         j->play_mode = 0;
4399                 } else {
4400                         retval = 1;
4401                 }
4402                 break;
4403         case TS85:
4404                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4405                         j->play_frame_size = 16;
4406                         j->play_mode = 0;
4407                 } else {
4408                         retval = 1;
4409                 }
4410                 break;
4411         case TS48:
4412                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4413                         j->play_frame_size = 9;
4414                         j->play_mode = 0;
4415                 } else {
4416                         retval = 1;
4417                 }
4418                 break;
4419         case TS41:
4420                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4421                         j->play_frame_size = 8;
4422                         j->play_mode = 0;
4423                 } else {
4424                         retval = 1;
4425                 }
4426                 break;
4427         case G728:
4428                 if (j->dsp.low != 0x20) {
4429                         j->play_frame_size = 48;
4430                         j->play_mode = 0;
4431                 } else {
4432                         retval = 1;
4433                 }
4434                 break;
4435         case G729:
4436                 if (j->dsp.low != 0x20) {
4437                         if (!j->flags.g729_loaded) {
4438                                 retval = 1;
4439                                 break;
4440                         }
4441                         switch (j->baseframe.low) {
4442                         case 0xA0:
4443                                 j->play_frame_size = 10;
4444                                 break;
4445                         case 0x50:
4446                                 j->play_frame_size = 5;
4447                                 break;
4448                         default:
4449                                 j->play_frame_size = 15;
4450                                 break;
4451                         }
4452                         j->play_mode = 0;
4453                 } else {
4454                         retval = 1;
4455                 }
4456                 break;
4457         case G729B:
4458                 if (j->dsp.low != 0x20) {
4459                         if (!j->flags.g729_loaded) {
4460                                 retval = 1;
4461                                 break;
4462                         }
4463                         switch (j->baseframe.low) {
4464                         case 0xA0:
4465                                 j->play_frame_size = 12;
4466                                 break;
4467                         case 0x50:
4468                                 j->play_frame_size = 6;
4469                                 break;
4470                         default:
4471                                 j->play_frame_size = 18;
4472                                 break;
4473                         }
4474                         j->play_mode = 0;
4475                 } else {
4476                         retval = 1;
4477                 }
4478                 break;
4479         case ULAW:
4480                 switch (j->baseframe.low) {
4481                 case 0xA0:
4482                         j->play_frame_size = 80;
4483                         break;
4484                 case 0x50:
4485                         j->play_frame_size = 40;
4486                         break;
4487                 default:
4488                         j->play_frame_size = 120;
4489                         break;
4490                 }
4491                 j->play_mode = 2;
4492                 break;
4493         case ALAW:
4494                 switch (j->baseframe.low) {
4495                 case 0xA0:
4496                         j->play_frame_size = 80;
4497                         break;
4498                 case 0x50:
4499                         j->play_frame_size = 40;
4500                         break;
4501                 default:
4502                         j->play_frame_size = 120;
4503                         break;
4504                 }
4505                 j->play_mode = 2;
4506                 break;
4507         case LINEAR16:
4508                 switch (j->baseframe.low) {
4509                 case 0xA0:
4510                         j->play_frame_size = 160;
4511                         break;
4512                 case 0x50:
4513                         j->play_frame_size = 80;
4514                         break;
4515                 default:
4516                         j->play_frame_size = 240;
4517                         break;
4518                 }
4519                 j->play_mode = 6;
4520                 break;
4521         case LINEAR8:
4522                 switch (j->baseframe.low) {
4523                 case 0xA0:
4524                         j->play_frame_size = 80;
4525                         break;
4526                 case 0x50:
4527                         j->play_frame_size = 40;
4528                         break;
4529                 default:
4530                         j->play_frame_size = 120;
4531                         break;
4532                 }
4533                 j->play_mode = 4;
4534                 break;
4535         case WSS:
4536                 switch (j->baseframe.low) {
4537                 case 0xA0:
4538                         j->play_frame_size = 80;
4539                         break;
4540                 case 0x50:
4541                         j->play_frame_size = 40;
4542                         break;
4543                 default:
4544                         j->play_frame_size = 120;
4545                         break;
4546                 }
4547                 j->play_mode = 5;
4548                 break;
4549         default:
4550                 j->play_frame_size = 0;
4551                 j->play_mode = -1;
4552                 if (j->write_buffer) {
4553                         kfree(j->write_buffer);
4554                         j->write_buffer = NULL;
4555                         j->write_buffer_size = 0;
4556                 }
4557                 retval = 1;
4558                 break;
4559         }
4560         return retval;
4561 }
4562
4563 static int ixj_play_start(IXJ *j)
4564 {
4565         unsigned short cmd = 0x0000;
4566
4567         if (j->write_buffer) {
4568                 ixj_play_stop(j);
4569         }
4570
4571         if(ixjdebug & 0x0002)
4572                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4573
4574         j->flags.playing = 1;
4575         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4576
4577         j->flags.play_first_frame = 1;
4578         j->drybuffer = 0;
4579
4580         if (!j->play_mode) {
4581                 switch (j->play_codec) {
4582                 case G723_63:
4583                         cmd = 0x5231;
4584                         break;
4585                 case G723_53:
4586                         cmd = 0x5232;
4587                         break;
4588                 case TS85:
4589                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4590
4591                         break;
4592                 case TS48:
4593                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4594
4595                         break;
4596                 case TS41:
4597                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4598
4599                         break;
4600                 case G728:
4601                         cmd = 0x5235;
4602                         break;
4603                 case G729:
4604                 case G729B:
4605                         cmd = 0x5236;
4606                         break;
4607                 default:
4608                         return 1;
4609                 }
4610                 if (ixj_WriteDSPCommand(cmd, j))
4611                         return -1;
4612         }
4613         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4614         if (!j->write_buffer) {
4615                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4616                 return -ENOMEM;
4617         }
4618 /*      j->write_buffers_empty = 2; */
4619         j->write_buffers_empty = 1;
4620         j->write_buffer_size = j->play_frame_size * 2;
4621         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4622         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4623
4624         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4625
4626                 return -1;
4627
4628         switch (j->play_mode) {
4629         case 0:
4630                 cmd = 0x2C03;
4631                 break;
4632         case 2:
4633                 if (j->ver.low == 0x12) {
4634                         cmd = 0x2C23;
4635                 } else {
4636                         cmd = 0x2C21;
4637                 }
4638                 break;
4639         case 4:
4640                 if (j->ver.low == 0x12) {
4641                         cmd = 0x2C43;
4642                 } else {
4643                         cmd = 0x2C41;
4644                 }
4645                 break;
4646         case 5:
4647                 if (j->ver.low == 0x12) {
4648                         cmd = 0x2C53;
4649                 } else {
4650                         cmd = 0x2C51;
4651                 }
4652                 break;
4653         case 6:
4654                 if (j->ver.low == 0x12) {
4655                         cmd = 0x2C63;
4656                 } else {
4657                         cmd = 0x2C61;
4658                 }
4659                 break;
4660         }
4661         if (ixj_WriteDSPCommand(cmd, j))
4662                 return -1;
4663
4664         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4665                 return -1;
4666
4667         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4668                 return -1;
4669
4670         if (j->flags.recording) {
4671                 ixj_aec_start(j, j->aec_level);
4672         }
4673
4674         return 0;
4675 }
4676
4677 static void ixj_play_stop(IXJ *j)
4678 {
4679         if(ixjdebug & 0x0002)
4680                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4681
4682         if (j->write_buffer) {
4683                 kfree(j->write_buffer);
4684                 j->write_buffer = NULL;
4685                 j->write_buffer_size = 0;
4686         }
4687         if (j->play_mode > -1) {
4688                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4689
4690                 j->play_mode = -1;
4691         }
4692         j->flags.playing = 0;
4693 }
4694
4695 static inline int get_play_level(IXJ *j)
4696 {
4697         int retval;
4698
4699         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4700         return j->ssr.high << 8 | j->ssr.low;
4701         retval = j->ssr.high << 8 | j->ssr.low;
4702         retval = (retval * 256) / 240;
4703         return retval;
4704 }
4705
4706 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4707 {
4708         unsigned int mask = 0;
4709
4710         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4711
4712         poll_wait(file_p, &(j->poll_q), wait);
4713         if (j->read_buffer_ready > 0)
4714                 mask |= POLLIN | POLLRDNORM;    /* readable */
4715         if (j->write_buffers_empty > 0)
4716                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4717         if (j->ex.bytes)
4718                 mask |= POLLPRI;
4719         return mask;
4720 }
4721
4722 static int ixj_play_tone(IXJ *j, char tone)
4723 {
4724         if (!j->tone_state) {
4725                 if(ixjdebug & 0x0002) {
4726                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4727                 }
4728                 if (j->dsp.low == 0x20) {
4729                         idle(j);
4730                 }
4731                 j->tone_start_jif = jiffies;
4732
4733                 j->tone_state = 1;
4734         }
4735
4736         j->tone_index = tone;
4737         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4738                 return -1;
4739
4740         return 0;
4741 }
4742
4743 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4744 {
4745         j->tone_on_time = arg;
4746
4747         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4748
4749                 return -1;
4750
4751         if (ixj_WriteDSPCommand(arg, j))
4752                 return -1;
4753
4754         return 0;
4755 }
4756
4757 static int SCI_WaitHighSCI(IXJ *j)
4758 {
4759         int cnt;
4760
4761         j->pld_scrr.byte = inb_p(j->XILINXbase);
4762         if (!j->pld_scrr.bits.sci) {
4763                 for (cnt = 0; cnt < 10; cnt++) {
4764                         udelay(32);
4765                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4766
4767                         if ((j->pld_scrr.bits.sci))
4768                                 return 1;
4769                 }
4770                 if (ixjdebug & 0x0001)
4771                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4772                 return 0;
4773         } else
4774                 return 1;
4775 }
4776
4777 static int SCI_WaitLowSCI(IXJ *j)
4778 {
4779         int cnt;
4780
4781         j->pld_scrr.byte = inb_p(j->XILINXbase);
4782         if (j->pld_scrr.bits.sci) {
4783                 for (cnt = 0; cnt < 10; cnt++) {
4784                         udelay(32);
4785                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4786
4787                         if (!(j->pld_scrr.bits.sci))
4788                                 return 1;
4789                 }
4790                 if (ixjdebug & 0x0001)
4791                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4792                 return 0;
4793         } else
4794                 return 1;
4795 }
4796
4797 static int SCI_Control(IXJ *j, int control)
4798 {
4799         switch (control) {
4800         case SCI_End:
4801                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4802
4803                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4804
4805                 break;
4806         case SCI_Enable_DAA:
4807                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4808
4809                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4810
4811                 break;
4812         case SCI_Enable_Mixer:
4813                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4814
4815                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4816
4817                 break;
4818         case SCI_Enable_EEPROM:
4819                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4820
4821                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4822
4823                 break;
4824         default:
4825                 return 0;
4826                 break;
4827         }
4828         outb_p(j->pld_scrw.byte, j->XILINXbase);
4829
4830         switch (control) {
4831         case SCI_End:
4832                 return 1;
4833                 break;
4834         case SCI_Enable_DAA:
4835         case SCI_Enable_Mixer:
4836         case SCI_Enable_EEPROM:
4837                 if (!SCI_WaitHighSCI(j))
4838                         return 0;
4839                 break;
4840         default:
4841                 return 0;
4842                 break;
4843         }
4844         return 1;
4845 }
4846
4847 static int SCI_Prepare(IXJ *j)
4848 {
4849         if (!SCI_Control(j, SCI_End))
4850                 return 0;
4851
4852         if (!SCI_WaitLowSCI(j))
4853                 return 0;
4854
4855         return 1;
4856 }
4857
4858 static int ixj_get_mixer(long val, IXJ *j)
4859 {
4860         int reg = (val & 0x1F00) >> 8;
4861         return j->mix.vol[reg];
4862 }
4863
4864 static int ixj_mixer(long val, IXJ *j)
4865 {
4866         BYTES bytes;
4867
4868         bytes.high = (val & 0x1F00) >> 8;
4869         bytes.low = val & 0x00FF;
4870
4871         /* save mixer value so we can get back later on */
4872         j->mix.vol[bytes.high] = bytes.low;
4873
4874         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4875
4876         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4877
4878         SCI_Control(j, SCI_Enable_Mixer);
4879
4880         SCI_Control(j, SCI_End);
4881
4882         return 0;
4883 }
4884
4885 static int daa_load(BYTES * p_bytes, IXJ *j)
4886 {
4887         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4888         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4889         if (!SCI_Control(j, SCI_Enable_DAA))
4890                 return 0;
4891         else
4892                 return 1;
4893 }
4894
4895 static int ixj_daa_cr4(IXJ *j, char reg)
4896 {
4897         BYTES bytes;
4898
4899         switch (j->daa_mode) {
4900         case SOP_PU_SLEEP:
4901                 bytes.high = 0x14;
4902                 break;
4903         case SOP_PU_RINGING:
4904                 bytes.high = 0x54;
4905                 break;
4906         case SOP_PU_CONVERSATION:
4907                 bytes.high = 0x94;
4908                 break;
4909         case SOP_PU_PULSEDIALING:
4910                 bytes.high = 0xD4;
4911                 break;
4912         }
4913
4914         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4915
4916         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4917         case 0:
4918                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4919                 break;
4920         case 1:
4921                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4922                 break;
4923         case 2:
4924                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4925                 break;
4926         case 3:
4927                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4928                 break;
4929         }
4930
4931         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4932
4933         if (!daa_load(&bytes, j))
4934                 return 0;
4935
4936         if (!SCI_Prepare(j))
4937                 return 0;
4938
4939         return 1;
4940 }
4941
4942 static char daa_int_read(IXJ *j)
4943 {
4944         BYTES bytes;
4945
4946         if (!SCI_Prepare(j))
4947                 return 0;
4948
4949         bytes.high = 0x38;
4950         bytes.low = 0x00;
4951         outb_p(bytes.high, j->XILINXbase + 0x03);
4952         outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954         if (!SCI_Control(j, SCI_Enable_DAA))
4955                 return 0;
4956
4957         bytes.high = inb_p(j->XILINXbase + 0x03);
4958         bytes.low = inb_p(j->XILINXbase + 0x02);
4959         if (bytes.low != ALISDAA_ID_BYTE) {
4960                 if (ixjdebug & 0x0001)
4961                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4962                 return 0;
4963         }
4964         if (!SCI_Control(j, SCI_Enable_DAA))
4965                 return 0;
4966         if (!SCI_Control(j, SCI_End))
4967                 return 0;
4968
4969         bytes.high = inb_p(j->XILINXbase + 0x03);
4970         bytes.low = inb_p(j->XILINXbase + 0x02);
4971
4972         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4973
4974         return 1;
4975 }
4976
4977 static char daa_CR_read(IXJ *j, int cr)
4978 {
4979         IXJ_WORD wdata;
4980         BYTES bytes;
4981
4982         if (!SCI_Prepare(j))
4983                 return 0;
4984
4985         switch (j->daa_mode) {
4986         case SOP_PU_SLEEP:
4987                 bytes.high = 0x30 + cr;
4988                 break;
4989         case SOP_PU_RINGING:
4990                 bytes.high = 0x70 + cr;
4991                 break;
4992         case SOP_PU_CONVERSATION:
4993                 bytes.high = 0xB0 + cr;
4994                 break;
4995         case SOP_PU_PULSEDIALING:
4996                 bytes.high = 0xF0 + cr;
4997                 break;
4998         }
4999
5000         bytes.low = 0x00;
5001
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         bytes.high = inb_p(j->XILINXbase + 0x03);
5009         bytes.low = inb_p(j->XILINXbase + 0x02);
5010         if (bytes.low != ALISDAA_ID_BYTE) {
5011                 if (ixjdebug & 0x0001)
5012                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5013                 return 0;
5014         }
5015         if (!SCI_Control(j, SCI_Enable_DAA))
5016                 return 0;
5017         if (!SCI_Control(j, SCI_End))
5018                 return 0;
5019
5020         wdata.word = inw_p(j->XILINXbase + 0x02);
5021
5022         switch(cr){
5023                 case 5:
5024                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
5025                         break;
5026                 case 4:
5027                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
5028                         break;
5029                 case 3:
5030                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
5031                         break;
5032                 case 2:
5033                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
5034                         break;
5035                 case 1:
5036                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
5037                         break;
5038                 case 0:
5039                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
5040                         break;
5041                 default:
5042                         return 0;
5043         }
5044         return 1;
5045 }
5046
5047 static int ixj_daa_cid_reset(IXJ *j)
5048 {
5049         int i;
5050         BYTES bytes;
5051
5052         if (ixjdebug & 0x0002)
5053                 printk("DAA Clearing CID ram\n");
5054
5055         if (!SCI_Prepare(j))
5056                 return 0;
5057
5058         bytes.high = 0x58;
5059         bytes.low = 0x00;
5060         outb_p(bytes.high, j->XILINXbase + 0x03);
5061         outb_p(bytes.low, j->XILINXbase + 0x02);
5062
5063         if (!SCI_Control(j, SCI_Enable_DAA))
5064                 return 0;
5065
5066         if (!SCI_WaitHighSCI(j))
5067                 return 0;
5068
5069         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
5070                 bytes.high = bytes.low = 0x00;
5071                 outb_p(bytes.high, j->XILINXbase + 0x03);
5072
5073                 if (i < ALISDAA_CALLERID_SIZE - 1)
5074                         outb_p(bytes.low, j->XILINXbase + 0x02);
5075
5076                 if (!SCI_Control(j, SCI_Enable_DAA))
5077                         return 0;
5078
5079                 if (!SCI_WaitHighSCI(j))
5080                         return 0;
5081
5082         }
5083
5084         if (!SCI_Control(j, SCI_End))
5085                 return 0;
5086
5087         if (ixjdebug & 0x0002)
5088                 printk("DAA CID ram cleared\n");
5089
5090         return 1;
5091 }
5092
5093 static int ixj_daa_cid_read(IXJ *j)
5094 {
5095         int i;
5096         BYTES bytes;
5097         char CID[ALISDAA_CALLERID_SIZE], mContinue;
5098         char *pIn, *pOut;
5099
5100         if (!SCI_Prepare(j))
5101                 return 0;
5102
5103         bytes.high = 0x78;
5104         bytes.low = 0x00;
5105         outb_p(bytes.high, j->XILINXbase + 0x03);
5106         outb_p(bytes.low, j->XILINXbase + 0x02);
5107
5108         if (!SCI_Control(j, SCI_Enable_DAA))
5109                 return 0;
5110
5111         if (!SCI_WaitHighSCI(j))
5112                 return 0;
5113
5114         bytes.high = inb_p(j->XILINXbase + 0x03);
5115         bytes.low = inb_p(j->XILINXbase + 0x02);
5116         if (bytes.low != ALISDAA_ID_BYTE) {
5117                 if (ixjdebug & 0x0001)
5118                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5119                 return 0;
5120         }
5121         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5122                 bytes.high = bytes.low = 0x00;
5123                 outb_p(bytes.high, j->XILINXbase + 0x03);
5124                 outb_p(bytes.low, j->XILINXbase + 0x02);
5125
5126                 if (!SCI_Control(j, SCI_Enable_DAA))
5127                         return 0;
5128
5129                 if (!SCI_WaitHighSCI(j))
5130                         return 0;
5131
5132                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5133                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5134         }
5135
5136         if (!SCI_Control(j, SCI_End))
5137                 return 0;
5138
5139         pIn = CID;
5140         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5141         mContinue = 1;
5142         while (mContinue) {
5143                 if ((pIn[1] & 0x03) == 0x01) {
5144                         pOut[0] = pIn[0];
5145                 }
5146                 if ((pIn[2] & 0x0c) == 0x04) {
5147                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5148                 }
5149                 if ((pIn[3] & 0x30) == 0x10) {
5150                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5151                 }
5152                 if ((pIn[4] & 0xc0) == 0x40) {
5153                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5154                 } else {
5155                         mContinue = FALSE;
5156                 }
5157                 pIn += 5, pOut += 4;
5158         }
5159         memset(&j->cid, 0, sizeof(PHONE_CID));
5160         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5161         pOut += 4;
5162         strncpy(j->cid.month, pOut, 2);
5163         pOut += 2;
5164         strncpy(j->cid.day, pOut, 2);
5165         pOut += 2;
5166         strncpy(j->cid.hour, pOut, 2);
5167         pOut += 2;
5168         strncpy(j->cid.min, pOut, 2);
5169         pOut += 3;
5170         j->cid.numlen = *pOut;
5171         pOut += 1;
5172         strncpy(j->cid.number, pOut, j->cid.numlen);
5173         pOut += j->cid.numlen + 1;
5174         j->cid.namelen = *pOut;
5175         pOut += 1;
5176         strncpy(j->cid.name, pOut, j->cid.namelen);
5177
5178         ixj_daa_cid_reset(j);
5179         return 1;
5180 }
5181
5182 static char daa_get_version(IXJ *j)
5183 {
5184         BYTES bytes;
5185
5186         if (!SCI_Prepare(j))
5187                 return 0;
5188
5189         bytes.high = 0x35;
5190         bytes.low = 0x00;
5191         outb_p(bytes.high, j->XILINXbase + 0x03);
5192         outb_p(bytes.low, j->XILINXbase + 0x02);
5193
5194         if (!SCI_Control(j, SCI_Enable_DAA))
5195                 return 0;
5196
5197         bytes.high = inb_p(j->XILINXbase + 0x03);
5198         bytes.low = inb_p(j->XILINXbase + 0x02);
5199         if (bytes.low != ALISDAA_ID_BYTE) {
5200                 if (ixjdebug & 0x0001)
5201                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5202                 return 0;
5203         }
5204         if (!SCI_Control(j, SCI_Enable_DAA))
5205                 return 0;
5206
5207         if (!SCI_Control(j, SCI_End))
5208                 return 0;
5209
5210         bytes.high = inb_p(j->XILINXbase + 0x03);
5211         bytes.low = inb_p(j->XILINXbase + 0x02);
5212         if (ixjdebug & 0x0002)
5213                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5214         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5215         return bytes.high;
5216 }
5217
5218 static int daa_set_mode(IXJ *j, int mode)
5219 {
5220         /* NOTE:
5221               The DAA *MUST* be in the conversation mode if the
5222               PSTN line is to be seized (PSTN line off-hook).
5223               Taking the PSTN line off-hook while the DAA is in
5224               a mode other than conversation mode will cause a
5225               hardware failure of the ALIS-A part.
5226
5227            NOTE:
5228               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5229               if the PSTN line is on-hook.  Failure to have the PSTN line
5230               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5231               ALIS-A part.
5232         */
5233
5234         BYTES bytes;
5235
5236         j->flags.pstn_rmr = 0;
5237
5238         if (!SCI_Prepare(j))
5239                 return 0;
5240
5241         switch (mode) {
5242         case SOP_PU_RESET:
5243                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5244
5245                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5246                 j->pld_slicw.bits.rly2 = 0;
5247                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5248                 bytes.high = 0x10;
5249                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5250                 daa_load(&bytes, j);
5251                 if (!SCI_Prepare(j))
5252                         return 0;
5253
5254                 j->daa_mode = SOP_PU_SLEEP;
5255                 break;
5256         case SOP_PU_SLEEP:
5257                 if(j->daa_mode == SOP_PU_SLEEP)
5258                 {
5259                         break;
5260                 }
5261                 if (ixjdebug & 0x0008)
5262                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5263 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5264                 {
5265                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5266
5267                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5268                         j->pld_slicw.bits.rly2 = 0;
5269                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5270                         bytes.high = 0x10;
5271                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5272                         daa_load(&bytes, j);
5273                         if (!SCI_Prepare(j))
5274                                 return 0;
5275                 }
5276                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5277
5278                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5279                 j->pld_slicw.bits.rly2 = 0;
5280                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5281                 bytes.high = 0x10;
5282                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5283                 daa_load(&bytes, j);
5284                 if (!SCI_Prepare(j))
5285                         return 0;
5286
5287                 j->daa_mode = SOP_PU_SLEEP;
5288                 j->flags.pstn_ringing = 0;
5289                 j->ex.bits.pstn_ring = 0;
5290                 j->pstn_sleeptil = jiffies + (hertz / 4);
5291                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5292                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5293                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5294                 break;
5295         case SOP_PU_RINGING:
5296                 if (ixjdebug & 0x0008)
5297                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5298                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5299
5300                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5301                 j->pld_slicw.bits.rly2 = 0;
5302                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5303                 bytes.high = 0x50;
5304                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5305                 daa_load(&bytes, j);
5306                 if (!SCI_Prepare(j))
5307                         return 0;
5308                 j->daa_mode = SOP_PU_RINGING;
5309                 break;
5310         case SOP_PU_CONVERSATION:
5311                 if (ixjdebug & 0x0008)
5312                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5313                 bytes.high = 0x90;
5314                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5315                 daa_load(&bytes, j);
5316                 if (!SCI_Prepare(j))
5317                         return 0;
5318                 j->pld_slicw.bits.rly2 = 1;
5319                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5320                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5321
5322                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5323                 j->daa_mode = SOP_PU_CONVERSATION;
5324                 j->flags.pstn_ringing = 0;
5325                 j->ex.bits.pstn_ring = 0;
5326                 j->pstn_sleeptil = jiffies;
5327                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5328                 break;
5329         case SOP_PU_PULSEDIALING:
5330                 if (ixjdebug & 0x0008)
5331                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5332                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5333
5334                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5335                 j->pld_slicw.bits.rly2 = 0;
5336                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5337                 bytes.high = 0xD0;
5338                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5339                 daa_load(&bytes, j);
5340                 if (!SCI_Prepare(j))
5341                         return 0;
5342                 j->daa_mode = SOP_PU_PULSEDIALING;
5343                 break;
5344         default:
5345                 break;
5346         }
5347         return 1;
5348 }
5349
5350 static int ixj_daa_write(IXJ *j)
5351 {
5352         BYTES bytes;
5353
5354         j->flags.pstncheck = 1;
5355
5356         daa_set_mode(j, SOP_PU_SLEEP);
5357
5358         if (!SCI_Prepare(j))
5359                 return 0;
5360
5361         outb_p(j->pld_scrw.byte, j->XILINXbase);
5362
5363         bytes.high = 0x14;
5364         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5365         if (!daa_load(&bytes, j))
5366                 return 0;
5367
5368         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5369         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5370         if (!daa_load(&bytes, j))
5371                 return 0;
5372
5373         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5374         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5375         if (!daa_load(&bytes, j))
5376                 return 0;
5377
5378         if (!SCI_Prepare(j))
5379                 return 0;
5380
5381         bytes.high = 0x1F;
5382         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5383         if (!daa_load(&bytes, j))
5384                 return 0;
5385
5386         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5387         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5388         if (!daa_load(&bytes, j))
5389                 return 0;
5390
5391         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5392         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5393         if (!daa_load(&bytes, j))
5394                 return 0;
5395
5396         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5397         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5398         if (!daa_load(&bytes, j))
5399                 return 0;
5400
5401         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5402         bytes.low = 0x00;
5403         if (!daa_load(&bytes, j))
5404                 return 0;
5405
5406         if (!SCI_Prepare(j))
5407                 return 0;
5408
5409         bytes.high = 0x00;
5410         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5411         if (!daa_load(&bytes, j))
5412                 return 0;
5413
5414         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5415         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5416         if (!daa_load(&bytes, j))
5417                 return 0;
5418
5419         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5420         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5421         if (!daa_load(&bytes, j))
5422                 return 0;
5423
5424         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5425         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5426         if (!daa_load(&bytes, j))
5427                 return 0;
5428
5429         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5430         bytes.low = 0x00;
5431         if (!daa_load(&bytes, j))
5432                 return 0;
5433
5434         if (!SCI_Control(j, SCI_End))
5435                 return 0;
5436         if (!SCI_WaitLowSCI(j))
5437                 return 0;
5438
5439         bytes.high = 0x01;
5440         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5441         if (!daa_load(&bytes, j))
5442                 return 0;
5443
5444         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5445         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5446         if (!daa_load(&bytes, j))
5447                 return 0;
5448
5449         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5450         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5451         if (!daa_load(&bytes, j))
5452                 return 0;
5453
5454         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5455         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5456         if (!daa_load(&bytes, j))
5457                 return 0;
5458
5459         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5460         bytes.low = 0x00;
5461         if (!daa_load(&bytes, j))
5462                 return 0;
5463
5464         if (!SCI_Control(j, SCI_End))
5465                 return 0;
5466         if (!SCI_WaitLowSCI(j))
5467                 return 0;
5468
5469         bytes.high = 0x02;
5470         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5471         if (!daa_load(&bytes, j))
5472                 return 0;
5473
5474         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5475         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5476         if (!daa_load(&bytes, j))
5477                 return 0;
5478
5479         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5480         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5481         if (!daa_load(&bytes, j))
5482                 return 0;
5483
5484         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5485         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5486         if (!daa_load(&bytes, j))
5487                 return 0;
5488
5489         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5490         bytes.low = 0x00;
5491         if (!daa_load(&bytes, j))
5492                 return 0;
5493
5494         if (!SCI_Control(j, SCI_End))
5495                 return 0;
5496         if (!SCI_WaitLowSCI(j))
5497                 return 0;
5498
5499         bytes.high = 0x03;
5500         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5501         if (!daa_load(&bytes, j))
5502                 return 0;
5503
5504         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5505         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5506         if (!daa_load(&bytes, j))
5507                 return 0;
5508
5509         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5510         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5511         if (!daa_load(&bytes, j))
5512                 return 0;
5513
5514         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5515         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5516         if (!daa_load(&bytes, j))
5517                 return 0;
5518
5519         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5520         bytes.low = 0x00;
5521         if (!daa_load(&bytes, j))
5522                 return 0;
5523
5524         if (!SCI_Control(j, SCI_End))
5525                 return 0;
5526         if (!SCI_WaitLowSCI(j))
5527                 return 0;
5528
5529         bytes.high = 0x04;
5530         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5531         if (!daa_load(&bytes, j))
5532                 return 0;
5533
5534         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5535         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5536         if (!daa_load(&bytes, j))
5537                 return 0;
5538
5539         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5540         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5541         if (!daa_load(&bytes, j))
5542                 return 0;
5543
5544         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5545         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5546         if (!daa_load(&bytes, j))
5547                 return 0;
5548
5549         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5550         bytes.low = 0x00;
5551         if (!daa_load(&bytes, j))
5552                 return 0;
5553
5554         if (!SCI_Control(j, SCI_End))
5555                 return 0;
5556         if (!SCI_WaitLowSCI(j))
5557                 return 0;
5558
5559         bytes.high = 0x05;
5560         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5561         if (!daa_load(&bytes, j))
5562                 return 0;
5563
5564         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5565         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5566         if (!daa_load(&bytes, j))
5567                 return 0;
5568
5569         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5570         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5571         if (!daa_load(&bytes, j))
5572                 return 0;
5573
5574         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5575         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5576         if (!daa_load(&bytes, j))
5577                 return 0;
5578
5579         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5580         bytes.low = 0x00;
5581         if (!daa_load(&bytes, j))
5582                 return 0;
5583
5584         if (!SCI_Control(j, SCI_End))
5585                 return 0;
5586         if (!SCI_WaitLowSCI(j))
5587                 return 0;
5588
5589         bytes.high = 0x06;
5590         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5591         if (!daa_load(&bytes, j))
5592                 return 0;
5593
5594         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5595         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5596         if (!daa_load(&bytes, j))
5597                 return 0;
5598
5599         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5600         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5601         if (!daa_load(&bytes, j))
5602                 return 0;
5603
5604         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5605         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5606         if (!daa_load(&bytes, j))
5607                 return 0;
5608
5609         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5610         bytes.low = 0x00;
5611         if (!daa_load(&bytes, j))
5612                 return 0;
5613
5614         if (!SCI_Control(j, SCI_End))
5615                 return 0;
5616         if (!SCI_WaitLowSCI(j))
5617                 return 0;
5618
5619         bytes.high = 0x07;
5620         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5621         if (!daa_load(&bytes, j))
5622                 return 0;
5623
5624         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5625         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5626         if (!daa_load(&bytes, j))
5627                 return 0;
5628
5629         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5630         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5631         if (!daa_load(&bytes, j))
5632                 return 0;
5633
5634         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5635         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5636         if (!daa_load(&bytes, j))
5637                 return 0;
5638
5639         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5640         bytes.low = 0x00;
5641         if (!daa_load(&bytes, j))
5642                 return 0;
5643
5644         if (!SCI_Control(j, SCI_End))
5645                 return 0;
5646         if (!SCI_WaitLowSCI(j))
5647                 return 0;
5648
5649         bytes.high = 0x08;
5650         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5651         if (!daa_load(&bytes, j))
5652                 return 0;
5653
5654         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5655         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5656         if (!daa_load(&bytes, j))
5657                 return 0;
5658
5659         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5660         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5661         if (!daa_load(&bytes, j))
5662                 return 0;
5663
5664         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5665         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5666         if (!daa_load(&bytes, j))
5667                 return 0;
5668
5669         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5670         bytes.low = 0x00;
5671         if (!daa_load(&bytes, j))
5672                 return 0;
5673
5674         if (!SCI_Control(j, SCI_End))
5675                 return 0;
5676         if (!SCI_WaitLowSCI(j))
5677                 return 0;
5678
5679         bytes.high = 0x09;
5680         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5681         if (!daa_load(&bytes, j))
5682                 return 0;
5683
5684         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5685         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5686         if (!daa_load(&bytes, j))
5687                 return 0;
5688
5689         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5690         bytes.low = 0x00;
5691         if (!daa_load(&bytes, j))
5692                 return 0;
5693
5694         if (!SCI_Control(j, SCI_End))
5695                 return 0;
5696         if (!SCI_WaitLowSCI(j))
5697                 return 0;
5698
5699         bytes.high = 0x0A;
5700         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5701         if (!daa_load(&bytes, j))
5702                 return 0;
5703
5704         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5705         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5706         if (!daa_load(&bytes, j))
5707                 return 0;
5708
5709         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5710         bytes.low = 0x00;
5711         if (!daa_load(&bytes, j))
5712                 return 0;
5713
5714         if (!SCI_Control(j, SCI_End))
5715                 return 0;
5716         if (!SCI_WaitLowSCI(j))
5717                 return 0;
5718
5719         bytes.high = 0x0B;
5720         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5721         if (!daa_load(&bytes, j))
5722                 return 0;
5723
5724         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5725         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5726         if (!daa_load(&bytes, j))
5727                 return 0;
5728
5729         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5730         bytes.low = 0x00;
5731         if (!daa_load(&bytes, j))
5732                 return 0;
5733
5734         if (!SCI_Control(j, SCI_End))
5735                 return 0;
5736         if (!SCI_WaitLowSCI(j))
5737                 return 0;
5738
5739         bytes.high = 0x0C;
5740         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5741         if (!daa_load(&bytes, j))
5742                 return 0;
5743
5744         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5745         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5746         if (!daa_load(&bytes, j))
5747                 return 0;
5748
5749         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5750         bytes.low = 0x00;
5751         if (!daa_load(&bytes, j))
5752                 return 0;
5753
5754         if (!SCI_Control(j, SCI_End))
5755                 return 0;
5756         if (!SCI_WaitLowSCI(j))
5757                 return 0;
5758
5759         bytes.high = 0x0D;
5760         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5761         if (!daa_load(&bytes, j))
5762                 return 0;
5763
5764         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5765         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5766         if (!daa_load(&bytes, j))
5767                 return 0;
5768
5769         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5770         bytes.low = 0x00;
5771         if (!daa_load(&bytes, j))
5772                 return 0;
5773
5774         if (!SCI_Control(j, SCI_End))
5775                 return 0;
5776         if (!SCI_WaitLowSCI(j))
5777                 return 0;
5778
5779         bytes.high = 0x0E;
5780         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5781         if (!daa_load(&bytes, j))
5782                 return 0;
5783
5784         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5785         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5786         if (!daa_load(&bytes, j))
5787                 return 0;
5788
5789         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5790         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5791         if (!daa_load(&bytes, j))
5792                 return 0;
5793
5794         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5795         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5796         if (!daa_load(&bytes, j))
5797                 return 0;
5798
5799         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5800         bytes.low = 0x00;
5801         if (!daa_load(&bytes, j))
5802                 return 0;
5803
5804         if (!SCI_Control(j, SCI_End))
5805                 return 0;
5806         if (!SCI_WaitLowSCI(j))
5807                 return 0;
5808
5809         bytes.high = 0x0F;
5810         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5811         if (!daa_load(&bytes, j))
5812                 return 0;
5813
5814         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5815         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5816         if (!daa_load(&bytes, j))
5817                 return 0;
5818
5819         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5820         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5821         if (!daa_load(&bytes, j))
5822                 return 0;
5823
5824         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5825         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5826         if (!daa_load(&bytes, j))
5827                 return 0;
5828
5829         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5830         bytes.low = 0x00;
5831         if (!daa_load(&bytes, j))
5832                 return 0;
5833
5834         udelay(32);
5835         j->pld_scrr.byte = inb_p(j->XILINXbase);
5836         if (!SCI_Control(j, SCI_End))
5837                 return 0;
5838
5839         outb_p(j->pld_scrw.byte, j->XILINXbase);
5840
5841         if (ixjdebug & 0x0002)
5842                 printk("DAA Coefficients Loaded\n");
5843
5844         j->flags.pstncheck = 0;
5845         return 1;
5846 }
5847
5848 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5849 {
5850         j->tone_off_time = arg;
5851         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5852
5853                 return -1;
5854         if (ixj_WriteDSPCommand(arg, j))
5855                 return -1;
5856         return 0;
5857 }
5858
5859 static int ixj_get_tone_on(IXJ *j)
5860 {
5861         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5862
5863                 return -1;
5864         return 0;
5865 }
5866
5867 static int ixj_get_tone_off(IXJ *j)
5868 {
5869         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5870
5871                 return -1;
5872         return 0;
5873 }
5874
5875 static void ixj_busytone(IXJ *j)
5876 {
5877         j->flags.ringback = 0;
5878         j->flags.dialtone = 0;
5879         j->flags.busytone = 1;
5880         ixj_set_tone_on(0x07D0, j);
5881         ixj_set_tone_off(0x07D0, j);
5882         ixj_play_tone(j, 27);
5883 }
5884
5885 static void ixj_dialtone(IXJ *j)
5886 {
5887         j->flags.ringback = 0;
5888         j->flags.dialtone = 1;
5889         j->flags.busytone = 0;
5890         if (j->dsp.low == 0x20) {
5891                 return;
5892         } else {
5893                 ixj_set_tone_on(0xFFFF, j);
5894                 ixj_set_tone_off(0x0000, j);
5895                 ixj_play_tone(j, 25);
5896         }
5897 }
5898
5899 static void ixj_cpt_stop(IXJ *j)
5900 {
5901         if(j->tone_state || j->tone_cadence_state)
5902         {
5903                 j->flags.dialtone = 0;
5904                 j->flags.busytone = 0;
5905                 j->flags.ringback = 0;
5906                 ixj_set_tone_on(0x0001, j);
5907                 ixj_set_tone_off(0x0000, j);
5908                 ixj_play_tone(j, 0);
5909                 j->tone_state = j->tone_cadence_state = 0;
5910                 if (j->cadence_t) {
5911                         if (j->cadence_t->ce) {
5912                                 kfree(j->cadence_t->ce);
5913                         }
5914                         kfree(j->cadence_t);
5915                         j->cadence_t = NULL;
5916                 }
5917         }
5918         if (j->play_mode == -1 && j->rec_mode == -1)
5919                 idle(j);
5920         if (j->play_mode != -1 && j->dsp.low == 0x20)
5921                 ixj_play_start(j);
5922         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5923                 ixj_record_start(j);
5924 }
5925
5926 static void ixj_ringback(IXJ *j)
5927 {
5928         j->flags.busytone = 0;
5929         j->flags.dialtone = 0;
5930         j->flags.ringback = 1;
5931         ixj_set_tone_on(0x0FA0, j);
5932         ixj_set_tone_off(0x2EE0, j);
5933         ixj_play_tone(j, 26);
5934 }
5935
5936 static void ixj_testram(IXJ *j)
5937 {
5938         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5939 }
5940
5941 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5942 {
5943         ixj_cadence *lcp;
5944         IXJ_CADENCE_ELEMENT __user *cep;
5945         IXJ_CADENCE_ELEMENT *lcep;
5946         IXJ_TONE ti;
5947         int err;
5948
5949         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5950         if (lcp == NULL)
5951                 return -ENOMEM;
5952
5953         err = -EFAULT;
5954         if (copy_from_user(&lcp->elements_used,
5955                            &cp->elements_used, sizeof(int)))
5956                 goto out;
5957         if (copy_from_user(&lcp->termination,
5958                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5959                 goto out;
5960         if (get_user(cep, &cp->ce))
5961                 goto out;
5962
5963         err = -EINVAL;
5964         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5965                 goto out;
5966
5967         err = -ENOMEM;
5968         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5969         if (!lcep)
5970                 goto out;
5971
5972         err = -EFAULT;
5973         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5974                 goto out1;
5975
5976         if (j->cadence_t) {
5977                 kfree(j->cadence_t->ce);
5978                 kfree(j->cadence_t);
5979         }
5980         lcp->ce = (void *) lcep;
5981         j->cadence_t = lcp;
5982         j->tone_cadence_state = 0;
5983         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5984         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5985         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5986                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5987                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5988                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5989                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5990                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5991                 ixj_init_tone(j, &ti);
5992         }
5993         ixj_play_tone(j, lcp->ce[0].index);
5994         return 1;
5995 out1:
5996         kfree(lcep);
5997 out:
5998         kfree(lcp);
5999         return err;
6000 }
6001
6002 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
6003 {
6004         IXJ_FILTER_CADENCE *lcp;
6005         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
6006         if (lcp == NULL) {
6007                 if(ixjdebug & 0x0001) {
6008                         printk(KERN_INFO "Could not allocate memory for cadence\n");
6009                 }
6010                 return -ENOMEM;
6011         }
6012         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
6013                 if(ixjdebug & 0x0001) {
6014                         printk(KERN_INFO "Could not copy cadence to kernel\n");
6015                 }
6016                 kfree(lcp);
6017                 return -EFAULT;
6018         }
6019         if (lcp->filter > 5) {
6020                 if(ixjdebug & 0x0001) {
6021                         printk(KERN_INFO "Cadence out of range\n");
6022                 }
6023                 kfree(lcp);
6024                 return -1;
6025         }
6026         j->cadence_f[lcp->filter].state = 0;
6027         j->cadence_f[lcp->filter].enable = lcp->enable;
6028         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
6029         j->cadence_f[lcp->filter].on1 = lcp->on1;
6030         j->cadence_f[lcp->filter].on1min = 0;
6031         j->cadence_f[lcp->filter].on1max = 0;
6032         j->cadence_f[lcp->filter].off1 = lcp->off1;
6033         j->cadence_f[lcp->filter].off1min = 0;
6034         j->cadence_f[lcp->filter].off1max = 0;
6035         j->cadence_f[lcp->filter].on2 = lcp->on2;
6036         j->cadence_f[lcp->filter].on2min = 0;
6037         j->cadence_f[lcp->filter].on2max = 0;
6038         j->cadence_f[lcp->filter].off2 = lcp->off2;
6039         j->cadence_f[lcp->filter].off2min = 0;
6040         j->cadence_f[lcp->filter].off2max = 0;
6041         j->cadence_f[lcp->filter].on3 = lcp->on3;
6042         j->cadence_f[lcp->filter].on3min = 0;
6043         j->cadence_f[lcp->filter].on3max = 0;
6044         j->cadence_f[lcp->filter].off3 = lcp->off3;
6045         j->cadence_f[lcp->filter].off3min = 0;
6046         j->cadence_f[lcp->filter].off3max = 0;
6047         kfree(lcp);
6048         if(ixjdebug & 0x0002) {
6049                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
6050         }
6051         return 0;
6052 }
6053
6054 static void add_caps(IXJ *j)
6055 {
6056         j->caps = 0;
6057         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
6058         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
6059         j->caplist[j->caps].captype = vendor;
6060         j->caplist[j->caps].handle = j->caps++;
6061         j->caplist[j->caps].captype = device;
6062         switch (j->cardtype) {
6063         case QTI_PHONEJACK:
6064                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
6065                 break;
6066         case QTI_LINEJACK:
6067                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
6068                 break;
6069         case QTI_PHONEJACK_LITE:
6070                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
6071                 break;
6072         case QTI_PHONEJACK_PCI:
6073                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
6074                 break;
6075         case QTI_PHONECARD:
6076                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
6077                 break;
6078         }
6079         j->caplist[j->caps].cap = j->cardtype;
6080         j->caplist[j->caps].handle = j->caps++;
6081         strcpy(j->caplist[j->caps].desc, "POTS");
6082         j->caplist[j->caps].captype = port;
6083         j->caplist[j->caps].cap = pots;
6084         j->caplist[j->caps].handle = j->caps++;
6085
6086         /* add devices that can do speaker/mic */
6087         switch (j->cardtype) {
6088         case QTI_PHONEJACK:
6089         case QTI_LINEJACK:
6090         case QTI_PHONEJACK_PCI:
6091         case QTI_PHONECARD:
6092                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
6093                 j->caplist[j->caps].captype = port;
6094                 j->caplist[j->caps].cap = speaker;
6095                 j->caplist[j->caps].handle = j->caps++;
6096         default:
6097                 break;
6098         }
6099
6100         /* add devices that can do handset */
6101         switch (j->cardtype) {
6102         case QTI_PHONEJACK:
6103                 strcpy(j->caplist[j->caps].desc, "HANDSET");
6104                 j->caplist[j->caps].captype = port;
6105                 j->caplist[j->caps].cap = handset;
6106                 j->caplist[j->caps].handle = j->caps++;
6107                 break;
6108         default:
6109                 break;
6110         }
6111
6112         /* add devices that can do PSTN */
6113         switch (j->cardtype) {
6114         case QTI_LINEJACK:
6115                 strcpy(j->caplist[j->caps].desc, "PSTN");
6116                 j->caplist[j->caps].captype = port;
6117                 j->caplist[j->caps].cap = pstn;
6118                 j->caplist[j->caps].handle = j->caps++;
6119                 break;
6120         default:
6121                 break;
6122         }
6123
6124         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6125         strcpy(j->caplist[j->caps].desc, "ULAW");
6126         j->caplist[j->caps].captype = codec;
6127         j->caplist[j->caps].cap = ULAW;
6128         j->caplist[j->caps].handle = j->caps++;
6129
6130         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6131         j->caplist[j->caps].captype = codec;
6132         j->caplist[j->caps].cap = LINEAR16;
6133         j->caplist[j->caps].handle = j->caps++;
6134
6135         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6136         j->caplist[j->caps].captype = codec;
6137         j->caplist[j->caps].cap = LINEAR8;
6138         j->caplist[j->caps].handle = j->caps++;
6139
6140         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6141         j->caplist[j->caps].captype = codec;
6142         j->caplist[j->caps].cap = WSS;
6143         j->caplist[j->caps].handle = j->caps++;
6144
6145         /* software ALAW codec, made from ULAW */
6146         strcpy(j->caplist[j->caps].desc, "ALAW");
6147         j->caplist[j->caps].captype = codec;
6148         j->caplist[j->caps].cap = ALAW;
6149         j->caplist[j->caps].handle = j->caps++;
6150
6151         /* version 12 of the 8020 does the following codecs in a broken way */
6152         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6153                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6154                 j->caplist[j->caps].captype = codec;
6155                 j->caplist[j->caps].cap = G723_63;
6156                 j->caplist[j->caps].handle = j->caps++;
6157
6158                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6159                 j->caplist[j->caps].captype = codec;
6160                 j->caplist[j->caps].cap = G723_53;
6161                 j->caplist[j->caps].handle = j->caps++;
6162
6163                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6164                 j->caplist[j->caps].captype = codec;
6165                 j->caplist[j->caps].cap = TS48;
6166                 j->caplist[j->caps].handle = j->caps++;
6167
6168                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6169                 j->caplist[j->caps].captype = codec;
6170                 j->caplist[j->caps].cap = TS41;
6171                 j->caplist[j->caps].handle = j->caps++;
6172         }
6173
6174         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6175         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6176                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6177                 j->caplist[j->caps].captype = codec;
6178                 j->caplist[j->caps].cap = TS85;
6179                 j->caplist[j->caps].handle = j->caps++;
6180         }
6181
6182         /* 8021 chips can do G728 */
6183         if (j->dsp.low == 0x21) {
6184                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6185                 j->caplist[j->caps].captype = codec;
6186                 j->caplist[j->caps].cap = G728;
6187                 j->caplist[j->caps].handle = j->caps++;
6188         }
6189
6190         /* 8021/8022 chips can do G729 if loaded */
6191         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6192                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6193                 j->caplist[j->caps].captype = codec;
6194                 j->caplist[j->caps].cap = G729;
6195                 j->caplist[j->caps].handle = j->caps++;
6196         }
6197         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6198                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6199                 j->caplist[j->caps].captype = codec;
6200                 j->caplist[j->caps].cap = G729B;
6201                 j->caplist[j->caps].handle = j->caps++;
6202         }
6203 }
6204
6205 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6206 {
6207         int cnt;
6208         int retval = 0;
6209         for (cnt = 0; cnt < j->caps; cnt++) {
6210                 if (pcreq->captype == j->caplist[cnt].captype
6211                     && pcreq->cap == j->caplist[cnt].cap) {
6212                         retval = 1;
6213                         break;
6214                 }
6215         }
6216         return retval;
6217 }
6218
6219 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6220 {
6221         IXJ_TONE ti;
6222         IXJ_FILTER jf;
6223         IXJ_FILTER_RAW jfr;
6224         void __user *argp = (void __user *)arg;
6225
6226         unsigned int raise, mant;
6227         unsigned int minor = iminor(inode);
6228         int board = NUM(inode);
6229
6230         IXJ *j = get_ixj(NUM(inode));
6231
6232         int retval = 0;
6233
6234         /*
6235          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6236          *    This is necessary to keep the DSP from locking up.
6237          */
6238         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6239                 set_current_state(TASK_INTERRUPTIBLE);
6240                 schedule_timeout(1);
6241         }
6242         if (ixjdebug & 0x0040)
6243                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6244         if (minor >= IXJMAX) {
6245                 clear_bit(board, &j->busyflags);
6246                 return -ENODEV;
6247         }
6248         /*
6249          *    Check ioctls only root can use.
6250          */
6251         if (!capable(CAP_SYS_ADMIN)) {
6252                 switch (cmd) {
6253                 case IXJCTL_TESTRAM:
6254                 case IXJCTL_HZ:
6255                         retval = -EPERM;
6256                 }
6257         }
6258         switch (cmd) {
6259         case IXJCTL_TESTRAM:
6260                 ixj_testram(j);
6261                 retval = (j->ssr.high << 8) + j->ssr.low;
6262                 break;
6263         case IXJCTL_CARDTYPE:
6264                 retval = j->cardtype;
6265                 break;
6266         case IXJCTL_SERIAL:
6267                 retval = j->serial;
6268                 break;
6269         case IXJCTL_VERSION:
6270                 if (copy_to_user(argp, ixj_c_revision, strlen(ixj_c_revision)))
6271                         retval = -EFAULT;
6272                 break;
6273         case PHONE_RING_CADENCE:
6274                 j->ring_cadence = arg;
6275                 break;
6276         case IXJCTL_CIDCW:
6277                 if(arg) {
6278                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6279                                 retval = -EFAULT;
6280                                 break;
6281                         }
6282                 } else {
6283                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6284                 }
6285                 ixj_write_cidcw(j);
6286                 break;
6287         /* Binary compatbility */
6288         case OLD_PHONE_RING_START:
6289                 arg = 0;
6290                 /* Fall through */
6291         case PHONE_RING_START:
6292                 if(arg) {
6293                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6294                                 retval = -EFAULT;
6295                                 break;
6296                         }
6297                         ixj_write_cid(j);
6298                 } else {
6299                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6300                 }
6301                 ixj_ring_start(j);
6302                 break;
6303         case PHONE_RING_STOP:
6304                 j->flags.cringing = 0;
6305                 if(j->cadence_f[5].enable) {
6306                         j->cadence_f[5].state = 0;
6307                 }
6308                 ixj_ring_off(j);
6309                 break;
6310         case PHONE_RING:
6311                 retval = ixj_ring(j);
6312                 break;
6313         case PHONE_EXCEPTION:
6314                 retval = j->ex.bytes;
6315                 if(j->ex.bits.flash) {
6316                         j->flash_end = 0;
6317                         j->ex.bits.flash = 0;
6318                 }
6319                 j->ex.bits.pstn_ring = 0;
6320                 j->ex.bits.caller_id = 0;
6321                 j->ex.bits.pstn_wink = 0;
6322                 j->ex.bits.f0 = 0;
6323                 j->ex.bits.f1 = 0;
6324                 j->ex.bits.f2 = 0;
6325                 j->ex.bits.f3 = 0;
6326                 j->ex.bits.fc0 = 0;
6327                 j->ex.bits.fc1 = 0;
6328                 j->ex.bits.fc2 = 0;
6329                 j->ex.bits.fc3 = 0;
6330                 j->ex.bits.reserved = 0;
6331                 break;
6332         case PHONE_HOOKSTATE:
6333                 j->ex.bits.hookstate = 0;
6334                 retval = j->hookstate;  //j->r_hook;
6335                 break;
6336         case IXJCTL_SET_LED:
6337                 LED_SetState(arg, j);
6338                 break;
6339         case PHONE_FRAME:
6340                 retval = set_base_frame(j, arg);
6341                 break;
6342         case PHONE_REC_CODEC:
6343                 retval = set_rec_codec(j, arg);
6344                 break;
6345         case PHONE_VAD:
6346                 ixj_vad(j, arg);
6347                 break;
6348         case PHONE_REC_START:
6349                 ixj_record_start(j);
6350                 break;
6351         case PHONE_REC_STOP:
6352                 ixj_record_stop(j);
6353                 break;
6354         case PHONE_REC_DEPTH:
6355                 set_rec_depth(j, arg);
6356                 break;
6357         case PHONE_REC_VOLUME:
6358                 if(arg == -1) {
6359                         retval = get_rec_volume(j);
6360                 }
6361                 else {
6362                         set_rec_volume(j, arg);
6363                         retval = arg;
6364                 }
6365                 break;
6366         case PHONE_REC_VOLUME_LINEAR:
6367                 if(arg == -1) {
6368                         retval = get_rec_volume_linear(j);
6369                 }
6370                 else {
6371                         set_rec_volume_linear(j, arg);
6372                         retval = arg;
6373                 }
6374                 break;
6375         case IXJCTL_DTMF_PRESCALE:
6376                 if(arg == -1) {
6377                         retval = get_dtmf_prescale(j);
6378                 }
6379                 else {
6380                         set_dtmf_prescale(j, arg);
6381                         retval = arg;
6382                 }
6383                 break;
6384         case PHONE_REC_LEVEL:
6385                 retval = get_rec_level(j);
6386                 break;
6387         case IXJCTL_SC_RXG:
6388                 retval = ixj_siadc(j, arg);
6389                 break;
6390         case IXJCTL_SC_TXG:
6391                 retval = ixj_sidac(j, arg);
6392                 break;
6393         case IXJCTL_AEC_START:
6394                 ixj_aec_start(j, arg);
6395                 break;
6396         case IXJCTL_AEC_STOP:
6397                 aec_stop(j);
6398                 break;
6399         case IXJCTL_AEC_GET_LEVEL:
6400                 retval = j->aec_level;
6401                 break;
6402         case PHONE_PLAY_CODEC:
6403                 retval = set_play_codec(j, arg);
6404                 break;
6405         case PHONE_PLAY_START:
6406                 retval = ixj_play_start(j);
6407                 break;
6408         case PHONE_PLAY_STOP:
6409                 ixj_play_stop(j);
6410                 break;
6411         case PHONE_PLAY_DEPTH:
6412                 set_play_depth(j, arg);
6413                 break;
6414         case PHONE_PLAY_VOLUME:
6415                 if(arg == -1) {
6416                         retval = get_play_volume(j);
6417                 }
6418                 else {
6419                         set_play_volume(j, arg);
6420                         retval = arg;
6421                 }
6422                 break;
6423         case PHONE_PLAY_VOLUME_LINEAR:
6424                 if(arg == -1) {
6425                         retval = get_play_volume_linear(j);
6426                 }
6427                 else {
6428                         set_play_volume_linear(j, arg);
6429                         retval = arg;
6430                 }
6431                 break;
6432         case PHONE_PLAY_LEVEL:
6433                 retval = get_play_level(j);
6434                 break;
6435         case IXJCTL_DSP_TYPE:
6436                 retval = (j->dsp.high << 8) + j->dsp.low;
6437                 break;
6438         case IXJCTL_DSP_VERSION:
6439                 retval = (j->ver.high << 8) + j->ver.low;
6440                 break;
6441         case IXJCTL_HZ:
6442                 hertz = arg;
6443                 break;
6444         case IXJCTL_RATE:
6445                 if (arg > hertz)
6446                         retval = -1;
6447                 else
6448                         samplerate = arg;
6449                 break;
6450         case IXJCTL_DRYBUFFER_READ:
6451                 put_user(j->drybuffer, (unsigned long __user *) argp);
6452                 break;
6453         case IXJCTL_DRYBUFFER_CLEAR:
6454                 j->drybuffer = 0;
6455                 break;
6456         case IXJCTL_FRAMES_READ:
6457                 put_user(j->framesread, (unsigned long __user *) argp);
6458                 break;
6459         case IXJCTL_FRAMES_WRITTEN:
6460                 put_user(j->frameswritten, (unsigned long __user *) argp);
6461                 break;
6462         case IXJCTL_READ_WAIT:
6463                 put_user(j->read_wait, (unsigned long __user *) argp);
6464                 break;
6465         case IXJCTL_WRITE_WAIT:
6466                 put_user(j->write_wait, (unsigned long __user *) argp);
6467                 break;
6468         case PHONE_MAXRINGS:
6469                 j->maxrings = arg;
6470                 break;
6471         case PHONE_SET_TONE_ON_TIME:
6472                 ixj_set_tone_on(arg, j);
6473                 break;
6474         case PHONE_SET_TONE_OFF_TIME:
6475                 ixj_set_tone_off(arg, j);
6476                 break;
6477         case PHONE_GET_TONE_ON_TIME:
6478                 if (ixj_get_tone_on(j)) {
6479                         retval = -1;
6480                 } else {
6481                         retval = (j->ssr.high << 8) + j->ssr.low;
6482                 }
6483                 break;
6484         case PHONE_GET_TONE_OFF_TIME:
6485                 if (ixj_get_tone_off(j)) {
6486                         retval = -1;
6487                 } else {
6488                         retval = (j->ssr.high << 8) + j->ssr.low;
6489                 }
6490                 break;
6491         case PHONE_PLAY_TONE:
6492                 if (!j->tone_state)
6493                         retval = ixj_play_tone(j, arg);
6494                 else
6495                         retval = -1;
6496                 break;
6497         case PHONE_GET_TONE_STATE:
6498                 retval = j->tone_state;
6499                 break;
6500         case PHONE_DTMF_READY:
6501                 retval = j->ex.bits.dtmf_ready;
6502                 break;
6503         case PHONE_GET_DTMF:
6504                 if (ixj_hookstate(j)) {
6505                         if (j->dtmf_rp != j->dtmf_wp) {
6506                                 retval = j->dtmfbuffer[j->dtmf_rp];
6507                                 j->dtmf_rp++;
6508                                 if (j->dtmf_rp == 79)
6509                                         j->dtmf_rp = 0;
6510                                 if (j->dtmf_rp == j->dtmf_wp) {
6511                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6512                                 }
6513                         }
6514                 }
6515                 break;
6516         case PHONE_GET_DTMF_ASCII:
6517                 if (ixj_hookstate(j)) {
6518                         if (j->dtmf_rp != j->dtmf_wp) {
6519                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6520                                 case 10:
6521                                         retval = 42;    /* '*'; */
6522
6523                                         break;
6524                                 case 11:
6525                                         retval = 48;    /*'0'; */
6526
6527                                         break;
6528                                 case 12:
6529                                         retval = 35;    /*'#'; */
6530
6531                                         break;
6532                                 case 28:
6533                                         retval = 65;    /*'A'; */
6534
6535                                         break;
6536                                 case 29:
6537                                         retval = 66;    /*'B'; */
6538
6539                                         break;
6540                                 case 30:
6541                                         retval = 67;    /*'C'; */
6542
6543                                         break;
6544                                 case 31:
6545                                         retval = 68;    /*'D'; */
6546
6547                                         break;
6548                                 default:
6549                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6550                                         break;
6551                                 }
6552                                 j->dtmf_rp++;
6553                                 if (j->dtmf_rp == 79)
6554                                         j->dtmf_rp = 0;
6555                                 if(j->dtmf_rp == j->dtmf_wp)
6556                                 {
6557                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6558                                 }
6559                         }
6560                 }
6561                 break;
6562         case PHONE_DTMF_OOB:
6563                 j->flags.dtmf_oob = arg;
6564                 break;
6565         case PHONE_DIALTONE:
6566                 ixj_dialtone(j);
6567                 break;
6568         case PHONE_BUSY:
6569                 ixj_busytone(j);
6570                 break;
6571         case PHONE_RINGBACK:
6572                 ixj_ringback(j);
6573                 break;
6574         case PHONE_WINK:
6575                 if(j->cardtype == QTI_PHONEJACK)
6576                         retval = -1;
6577                 else
6578                         retval = ixj_wink(j);
6579                 break;
6580         case PHONE_CPT_STOP:
6581                 ixj_cpt_stop(j);
6582                 break;
6583         case PHONE_QUERY_CODEC:
6584         {
6585                 struct phone_codec_data pd;
6586                 int val;
6587                 int proto_size[] = {
6588                         -1,
6589                         12, 10, 16, 9, 8, 48, 5,
6590                         40, 40, 80, 40, 40, 6
6591                 };
6592                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6593                         retval = -EFAULT;
6594                         break;
6595                 }
6596                 if(pd.type<1 || pd.type>13) {
6597                         retval = -EPROTONOSUPPORT;
6598                         break;
6599                 }
6600                 if(pd.type<G729)
6601                         val=proto_size[pd.type];
6602                 else switch(j->baseframe.low)
6603                 {
6604                         case 0xA0:val=2*proto_size[pd.type];break;
6605                         case 0x50:val=proto_size[pd.type];break;
6606                         default:val=proto_size[pd.type]*3;break;
6607                 }
6608                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6609                 if(copy_to_user(argp, &pd, sizeof(pd)))
6610                         retval = -EFAULT;
6611                 break;
6612         }
6613         case IXJCTL_DSP_IDLE:
6614                 idle(j);
6615                 break;
6616         case IXJCTL_MIXER:
6617                 if ((arg & 0xff) == 0xff)
6618                         retval = ixj_get_mixer(arg, j);
6619                 else
6620                         ixj_mixer(arg, j);
6621                 break;
6622         case IXJCTL_DAA_COEFF_SET:
6623                 switch (arg) {
6624                 case DAA_US:
6625                         DAA_Coeff_US(j);
6626                         retval = ixj_daa_write(j);
6627                         break;
6628                 case DAA_UK:
6629                         DAA_Coeff_UK(j);
6630                         retval = ixj_daa_write(j);
6631                         break;
6632                 case DAA_FRANCE:
6633                         DAA_Coeff_France(j);
6634                         retval = ixj_daa_write(j);
6635                         break;
6636                 case DAA_GERMANY:
6637                         DAA_Coeff_Germany(j);
6638                         retval = ixj_daa_write(j);
6639                         break;
6640                 case DAA_AUSTRALIA:
6641                         DAA_Coeff_Australia(j);
6642                         retval = ixj_daa_write(j);
6643                         break;
6644                 case DAA_JAPAN:
6645                         DAA_Coeff_Japan(j);
6646                         retval = ixj_daa_write(j);
6647                         break;
6648                 default:
6649                         retval = 1;
6650                         break;
6651                 }
6652                 break;
6653         case IXJCTL_DAA_AGAIN:
6654                 ixj_daa_cr4(j, arg | 0x02);
6655                 break;
6656         case IXJCTL_PSTN_LINETEST:
6657                 retval = ixj_linetest(j);
6658                 break;
6659         case IXJCTL_VMWI:
6660                 ixj_write_vmwi(j, arg);
6661                 break;
6662         case IXJCTL_CID:
6663                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6664                         retval = -EFAULT;
6665                 j->ex.bits.caller_id = 0;
6666                 break;
6667         case IXJCTL_WINK_DURATION:
6668                 j->winktime = arg;
6669                 break;
6670         case IXJCTL_PORT:
6671                 if (arg)
6672                         retval = ixj_set_port(j, arg);
6673                 else
6674                         retval = j->port;
6675                 break;
6676         case IXJCTL_POTS_PSTN:
6677                 retval = ixj_set_pots(j, arg);
6678                 break;
6679         case PHONE_CAPABILITIES:
6680                 add_caps(j);
6681                 retval = j->caps;
6682                 break;
6683         case PHONE_CAPABILITIES_LIST:
6684                 add_caps(j);
6685                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6686                         retval = -EFAULT;
6687                 break;
6688         case PHONE_CAPABILITIES_CHECK:
6689                 {
6690                         struct phone_capability cap;
6691                         if (copy_from_user(&cap, argp, sizeof(cap)))
6692                                 retval = -EFAULT;
6693                         else {
6694                                 add_caps(j);
6695                                 retval = capabilities_check(j, &cap);
6696                         }
6697                 }
6698                 break;
6699         case PHONE_PSTN_SET_STATE:
6700                 daa_set_mode(j, arg);
6701                 break;
6702         case PHONE_PSTN_GET_STATE:
6703                 retval = j->daa_mode;
6704                 j->ex.bits.pstn_ring = 0;
6705                 break;
6706         case IXJCTL_SET_FILTER:
6707                 if (copy_from_user(&jf, argp, sizeof(jf)))
6708                         retval = -EFAULT;
6709                 retval = ixj_init_filter(j, &jf);
6710                 break;
6711         case IXJCTL_SET_FILTER_RAW:
6712                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6713                         retval = -EFAULT;
6714                 else
6715                         retval = ixj_init_filter_raw(j, &jfr);
6716                 break;
6717         case IXJCTL_GET_FILTER_HIST:
6718                 if(arg<0||arg>3)
6719                         retval = -EINVAL;
6720                 else
6721                         retval = j->filter_hist[arg];
6722                 break;
6723         case IXJCTL_INIT_TONE:
6724                 if (copy_from_user(&ti, argp, sizeof(ti)))
6725                         retval = -EFAULT;
6726                 else
6727                         retval = ixj_init_tone(j, &ti);
6728                 break;
6729         case IXJCTL_TONE_CADENCE:
6730                 retval = ixj_build_cadence(j, argp);
6731                 break;
6732         case IXJCTL_FILTER_CADENCE:
6733                 retval = ixj_build_filter_cadence(j, argp);
6734                 break;
6735         case IXJCTL_SIGCTL:
6736                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6737                         retval = -EFAULT;
6738                         break;
6739                 }
6740                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6741                 if(j->sigdef.event < 33) {
6742                         raise = 1;
6743                         for(mant = 0; mant < j->sigdef.event; mant++){
6744                                 raise *= 2;
6745                         }
6746                         if(j->sigdef.signal)
6747                                 j->ex_sig.bytes |= raise;
6748                         else
6749                                 j->ex_sig.bytes &= (raise^0xffff);
6750                 }
6751                 break;
6752         case IXJCTL_INTERCOM_STOP:
6753                 if(arg < 0 || arg >= IXJMAX)
6754                         return -EINVAL;
6755                 j->intercom = -1;
6756                 ixj_record_stop(j);
6757                 ixj_play_stop(j);
6758                 idle(j);
6759                 get_ixj(arg)->intercom = -1;
6760                 ixj_record_stop(get_ixj(arg));
6761                 ixj_play_stop(get_ixj(arg));
6762                 idle(get_ixj(arg));
6763                 break;
6764         case IXJCTL_INTERCOM_START:
6765                 if(arg < 0 || arg >= IXJMAX)
6766                         return -EINVAL;
6767                 j->intercom = arg;
6768                 ixj_record_start(j);
6769                 ixj_play_start(j);
6770                 get_ixj(arg)->intercom = board;
6771                 ixj_play_start(get_ixj(arg));
6772                 ixj_record_start(get_ixj(arg));
6773                 break;
6774         }
6775         if (ixjdebug & 0x0040)
6776                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6777         clear_bit(board, &j->busyflags);
6778         return retval;
6779 }
6780
6781 static int ixj_fasync(int fd, struct file *file_p, int mode)
6782 {
6783         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6784
6785         return fasync_helper(fd, file_p, mode, &j->async_queue);
6786 }
6787
6788 struct file_operations ixj_fops =
6789 {
6790         .owner          = THIS_MODULE,
6791         .read           = ixj_enhanced_read,
6792         .write          = ixj_enhanced_write,
6793         .poll           = ixj_poll,
6794         .ioctl          = ixj_ioctl,
6795         .release        = ixj_release,
6796         .fasync         = ixj_fasync
6797 };
6798
6799 static int ixj_linetest(IXJ *j)
6800 {
6801         unsigned long jifwait;
6802
6803         j->flags.pstncheck = 1; /* Testing */
6804         j->flags.pstn_present = 0; /* Assume the line is not there */
6805
6806         daa_int_read(j);        /*Clear DAA Interrupt flags */
6807         /* */
6808         /* Hold all relays in the normally de-energized position. */
6809         /* */
6810
6811         j->pld_slicw.bits.rly1 = 0;
6812         j->pld_slicw.bits.rly2 = 0;
6813         j->pld_slicw.bits.rly3 = 0;
6814         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6815         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6816
6817         outb_p(j->pld_scrw.byte, j->XILINXbase);
6818         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6819         if (j->pld_slicr.bits.potspstn) {
6820                 j->flags.pots_pstn = 1;
6821                 j->flags.pots_correct = 0;
6822                 LED_SetState(0x4, j);
6823         } else {
6824                 j->flags.pots_pstn = 0;
6825                 j->pld_slicw.bits.rly1 = 0;
6826                 j->pld_slicw.bits.rly2 = 0;
6827                 j->pld_slicw.bits.rly3 = 1;
6828                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6829                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6830
6831                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6832                 daa_set_mode(j, SOP_PU_CONVERSATION);
6833                 jifwait = jiffies + hertz;
6834                 while (time_before(jiffies, jifwait)) {
6835                         set_current_state(TASK_INTERRUPTIBLE);
6836                         schedule_timeout(1);
6837                 }
6838                 daa_int_read(j);
6839                 daa_set_mode(j, SOP_PU_RESET);
6840                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6841                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6842                         LED_SetState(0x4, j);
6843                         j->pld_slicw.bits.rly3 = 0;
6844                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6845                 } else {
6846                         j->flags.pots_correct = 1;
6847                         LED_SetState(0x8, j);
6848                         j->pld_slicw.bits.rly1 = 1;
6849                         j->pld_slicw.bits.rly2 = 0;
6850                         j->pld_slicw.bits.rly3 = 0;
6851                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6852                 }
6853         }
6854         j->pld_slicw.bits.rly3 = 0;
6855         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6856         daa_set_mode(j, SOP_PU_CONVERSATION);
6857         jifwait = jiffies + hertz;
6858         while (time_before(jiffies, jifwait)) {
6859                 set_current_state(TASK_INTERRUPTIBLE);
6860                 schedule_timeout(1);
6861         }
6862         daa_int_read(j);
6863         daa_set_mode(j, SOP_PU_RESET);
6864         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6865                 j->pstn_sleeptil = jiffies + (hertz / 4);
6866                 j->flags.pstn_present = 1;
6867         } else {
6868                 j->flags.pstn_present = 0;
6869         }
6870         if (j->flags.pstn_present) {
6871                 if (j->flags.pots_correct) {
6872                         LED_SetState(0xA, j);
6873                 } else {
6874                         LED_SetState(0x6, j);
6875                 }
6876         } else {
6877                 if (j->flags.pots_correct) {
6878                         LED_SetState(0x9, j);
6879                 } else {
6880                         LED_SetState(0x5, j);
6881                 }
6882         }
6883         j->flags.pstncheck = 0; /* Testing */
6884         return j->flags.pstn_present;
6885 }
6886
6887 static int ixj_selfprobe(IXJ *j)
6888 {
6889         unsigned short cmd;
6890         unsigned long jif;
6891         int cnt;
6892         BYTES bytes;
6893
6894         init_waitqueue_head(&j->poll_q);
6895         init_waitqueue_head(&j->read_q);
6896         init_waitqueue_head(&j->write_q);
6897
6898         while(atomic_read(&j->DSPWrite) > 0)
6899                 atomic_dec(&j->DSPWrite);
6900         if (ixjdebug & 0x0002)
6901                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6902         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6903
6904         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6905                 return -1;
6906 /* The read values of the SSR should be 0x00 for the IDLE command */
6907         if (j->ssr.low || j->ssr.high)
6908                 return -1;
6909         if (ixjdebug & 0x0002)
6910                 printk(KERN_INFO "Get Device ID Code\n");
6911         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6912                 return -1;
6913         j->dsp.low = j->ssr.low;
6914         j->dsp.high = j->ssr.high;
6915         if (ixjdebug & 0x0002)
6916                 printk(KERN_INFO "Get Device Version Code\n");
6917         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6918                 return -1;
6919         j->ver.low = j->ssr.low;
6920         j->ver.high = j->ssr.high;
6921         if (!j->cardtype) {
6922                 if (j->dsp.low == 0x21) {
6923                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6924                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6925 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6926                         bytes.low = inb_p(j->XILINXbase + 0x02);
6927                         if (bytes.low == bytes.high)    /*  Register is read only on */
6928                                 /*  Internet PhoneJack Lite */
6929                          {
6930                                 j->cardtype = QTI_PHONEJACK_LITE;
6931                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6932                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6933                                         return -1;
6934                                 }
6935                                 j->pld_slicw.pcib.e1 = 1;
6936                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6937                         } else {
6938                                 j->cardtype = QTI_LINEJACK;
6939
6940                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6941                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6942                                         return -1;
6943                                 }
6944                         }
6945                 } else if (j->dsp.low == 0x22) {
6946                         j->cardtype = QTI_PHONEJACK_PCI;
6947                         request_region(j->XILINXbase, 4, "ixj control");
6948                         j->pld_slicw.pcib.e1 = 1;
6949                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6950                 } else
6951                         j->cardtype = QTI_PHONEJACK;
6952         } else {
6953                 switch (j->cardtype) {
6954                 case QTI_PHONEJACK:
6955                         if (!j->dsp.low != 0x20) {
6956                                 j->dsp.high = 0x80;
6957                                 j->dsp.low = 0x20;
6958                                 ixj_WriteDSPCommand(0x3800, j);
6959                                 j->ver.low = j->ssr.low;
6960                                 j->ver.high = j->ssr.high;
6961                         }
6962                         break;
6963                 case QTI_LINEJACK:
6964                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6965                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6966                                 return -1;
6967                         }
6968                         break;
6969                 case QTI_PHONEJACK_LITE:
6970                 case QTI_PHONEJACK_PCI:
6971                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6972                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6973                                 return -1;
6974                         }
6975                         j->pld_slicw.pcib.e1 = 1;
6976                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6977                         break;
6978                 case QTI_PHONECARD:
6979                         break;
6980                 }
6981         }
6982         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6983                 if (ixjdebug & 0x0002)
6984                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6985                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6986                         return -1;
6987                 if (ixjdebug & 0x0002)
6988                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6989                 if (j->cardtype == QTI_PHONEJACK) {
6990                         cmd = 0x9FF2;
6991                 } else {
6992                         cmd = 0x9FF5;
6993                 }
6994                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6995                         return -1;
6996         } else {
6997                 if (set_base_frame(j, 30) != 30)
6998                         return -1;
6999                 if (ixjdebug & 0x0002)
7000                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
7001                 if (j->cardtype == QTI_PHONECARD) {
7002                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
7003                                 return -1;
7004                 }
7005                 if (j->cardtype == QTI_LINEJACK) {
7006                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
7007                                 return -1;
7008                         if (ixjdebug & 0x0002)
7009                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
7010                         j->pld_clock.byte = 0;
7011                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
7012                 }
7013         }
7014
7015         if (j->dsp.low == 0x20) {
7016                 if (ixjdebug & 0x0002)
7017                         printk(KERN_INFO "Configure GPIO pins\n");
7018                 j->gpio.bytes.high = 0x09;
7019 /*  bytes.low = 0xEF;  0xF7 */
7020                 j->gpio.bits.gpio1 = 1;
7021                 j->gpio.bits.gpio2 = 1;
7022                 j->gpio.bits.gpio3 = 0;
7023                 j->gpio.bits.gpio4 = 1;
7024                 j->gpio.bits.gpio5 = 1;
7025                 j->gpio.bits.gpio6 = 1;
7026                 j->gpio.bits.gpio7 = 1;
7027                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
7028                 if (ixjdebug & 0x0002)
7029                         printk(KERN_INFO "Enable SLIC\n");
7030                 j->gpio.bytes.high = 0x0B;
7031                 j->gpio.bytes.low = 0x00;
7032                 j->gpio.bits.gpio1 = 0;
7033                 j->gpio.bits.gpio2 = 1;
7034                 j->gpio.bits.gpio5 = 0;
7035                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
7036                 j->port = PORT_POTS;
7037         } else {
7038                 if (j->cardtype == QTI_LINEJACK) {
7039                         LED_SetState(0x1, j);
7040                         jif = jiffies + (hertz / 10);
7041                         while (time_before(jiffies, jif)) {
7042                                 set_current_state(TASK_INTERRUPTIBLE);
7043                                 schedule_timeout(1);
7044                         }
7045                         LED_SetState(0x2, j);
7046                         jif = jiffies + (hertz / 10);
7047                         while (time_before(jiffies, jif)) {
7048                                 set_current_state(TASK_INTERRUPTIBLE);
7049                                 schedule_timeout(1);
7050                         }
7051                         LED_SetState(0x4, j);
7052                         jif = jiffies + (hertz / 10);
7053                         while (time_before(jiffies, jif)) {
7054                                 set_current_state(TASK_INTERRUPTIBLE);
7055                                 schedule_timeout(1);
7056                         }
7057                         LED_SetState(0x8, j);
7058                         jif = jiffies + (hertz / 10);
7059                         while (time_before(jiffies, jif)) {
7060                                 set_current_state(TASK_INTERRUPTIBLE);
7061                                 schedule_timeout(1);
7062                         }
7063                         LED_SetState(0x0, j);
7064                         daa_get_version(j);
7065                         if (ixjdebug & 0x0002)
7066                                 printk("Loading DAA Coefficients\n");
7067                         DAA_Coeff_US(j);
7068                         if (!ixj_daa_write(j)) {
7069                                 printk("DAA write failed on board %d\n", j->board);
7070                                 return -1;
7071                         }
7072                         if(!ixj_daa_cid_reset(j)) {
7073                                 printk("DAA CID reset failed on board %d\n", j->board);
7074                                 return -1;
7075                         }
7076                         j->flags.pots_correct = 0;
7077                         j->flags.pstn_present = 0;
7078                         ixj_linetest(j);
7079                         if (j->flags.pots_correct) {
7080                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7081
7082                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7083                                 j->pld_slicw.bits.rly1 = 1;
7084                                 j->pld_slicw.bits.spken = 1;
7085                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7086                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7087 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7088                                 j->port = PORT_POTS;
7089                         }
7090                         ixj_set_port(j, PORT_PSTN);
7091                         ixj_set_pots(j, 1);
7092                         if (ixjdebug & 0x0002)
7093                                 printk(KERN_INFO "Enable Mixer\n");
7094                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
7095                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
7096
7097                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
7098                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
7099
7100                         ixj_mixer(0x0480, j);   /*FM Left mute */
7101                         ixj_mixer(0x0580, j);   /*FM Right mute */
7102
7103                         ixj_mixer(0x0680, j);   /*CD Left mute */
7104                         ixj_mixer(0x0780, j);   /*CD Right mute */
7105
7106                         ixj_mixer(0x0880, j);   /*Line Left mute */
7107                         ixj_mixer(0x0980, j);   /*Line Right mute */
7108
7109                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
7110                         ixj_mixer(0x0B80, j);   /*Aux right mute */
7111
7112                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
7113                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
7114
7115                         ixj_mixer(0x0E80, j);   /*Mic mute */
7116
7117                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
7118
7119                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
7120                         ixj_mixer(0x110C, j);
7121
7122
7123                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
7124                         ixj_mixer(0x1401, j);
7125
7126                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
7127                         ixj_mixer(0x1501, j);
7128
7129                         ixj_mixer(0x1700, j);   /*Clock select */
7130
7131                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
7132
7133                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
7134
7135                         if (ixjdebug & 0x0002)
7136                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7137                         j->cadence_f[4].state = 0;
7138                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7139                         j->cadence_f[4].off1 = 0;
7140                         j->cadence_f[4].on2 = 0;
7141                         j->cadence_f[4].off2 = 0;
7142                         j->cadence_f[4].on3 = 0;
7143                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7144                         j->pstn_last_rmr = jiffies;
7145
7146                 } else {
7147                         if (j->cardtype == QTI_PHONECARD) {
7148                                 ixj_WriteDSPCommand(0xCF07, j);
7149                                 ixj_WriteDSPCommand(0x00B0, j);
7150                                 ixj_set_port(j, PORT_SPEAKER);
7151                         } else {
7152                                 ixj_set_port(j, PORT_POTS);
7153                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7154 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7155                         }
7156                 }
7157         }
7158
7159         j->intercom = -1;
7160         j->framesread = j->frameswritten = 0;
7161         j->read_wait = j->write_wait = 0;
7162         j->rxreadycheck = j->txreadycheck = 0;
7163
7164         /* initialise the DTMF prescale to a sensible value */
7165         if (j->cardtype == QTI_LINEJACK) {
7166                 set_dtmf_prescale(j, 0x10);
7167         } else {
7168                 set_dtmf_prescale(j, 0x40);
7169         }
7170         set_play_volume(j, 0x100);
7171         set_rec_volume(j, 0x100);
7172
7173         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7174                 return -1;
7175 /* The read values of the SSR should be 0x00 for the IDLE command */
7176         if (j->ssr.low || j->ssr.high)
7177                 return -1;
7178
7179         if (ixjdebug & 0x0002)
7180                 printk(KERN_INFO "Enable Line Monitor\n");
7181
7182         if (ixjdebug & 0x0002)
7183                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7184
7185         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7186                 return -1;
7187
7188         if (ixjdebug & 0x002)
7189                 printk(KERN_INFO "Enable DTMF Detectors\n");
7190
7191         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7192                 return -1;
7193
7194         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7195                 return -1;
7196
7197         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7198
7199         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7200
7201         j->ex.bits.dtmf_ready = 0;
7202         j->dtmf_state = 0;
7203         j->dtmf_wp = j->dtmf_rp = 0;
7204         j->rec_mode = j->play_mode = -1;
7205         j->flags.ringing = 0;
7206         j->maxrings = MAXRINGS;
7207         j->ring_cadence = USA_RING_CADENCE;
7208         j->drybuffer = 0;
7209         j->winktime = 320;
7210         j->flags.dtmf_oob = 0;
7211         for (cnt = 0; cnt < 4; cnt++)
7212                 j->cadence_f[cnt].enable = 0;
7213         /* must be a device on the specified address */
7214         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7215
7216         /* Set up the default signals for events */
7217         for (cnt = 0; cnt < 35; cnt++)
7218                 j->ixj_signals[cnt] = SIGIO;
7219
7220         /* Set the excetion signal enable flags */
7221         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7222         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 =
7223         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;
7224 #ifdef IXJ_DYN_ALLOC
7225         j->fskdata = NULL;
7226 #endif
7227         j->fskdcnt = 0;
7228         j->cidcw_wait = 0;
7229
7230         /* Register with the Telephony for Linux subsystem */
7231         j->p.f_op = &ixj_fops;
7232         j->p.open = ixj_open;
7233         j->p.board = j->board;
7234         phone_register_device(&j->p, PHONE_UNIT_ANY);
7235
7236         ixj_init_timer(j);
7237         ixj_add_timer(j);
7238         return 0;
7239 }
7240
7241 /*
7242  *      Exported service for pcmcia card handling
7243  */
7244
7245 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7246 {
7247         IXJ *j = ixj_alloc();
7248
7249         j->board = 0;
7250
7251         j->DSPbase = dsp;
7252         j->XILINXbase = xilinx;
7253         j->cardtype = QTI_PHONECARD;
7254         ixj_selfprobe(j);
7255         return j;
7256 }
7257
7258 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7259
7260 static int ixj_get_status_proc(char *buf)
7261 {
7262         int len;
7263         int cnt;
7264         IXJ *j;
7265         len = 0;
7266         len += sprintf(buf + len, "%s", ixj_c_rcsid);
7267         len += sprintf(buf + len, "\n%s", ixj_h_rcsid);
7268         len += sprintf(buf + len, "\n%s", ixjuser_h_rcsid);
7269         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7270         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7271         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7272         len += sprintf(buf + len, "\nUsing old telephony API");
7273         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7274
7275         for (cnt = 0; cnt < IXJMAX; cnt++) {
7276                 j = get_ixj(cnt);
7277                 if(j==NULL)
7278                         continue;
7279                 if (j->DSPbase) {
7280                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7281                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7282                         if (j->cardtype != QTI_PHONEJACK)
7283                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7284                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7285                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7286                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7287                         switch (j->cardtype) {
7288                         case (QTI_PHONEJACK):
7289                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7290                                 break;
7291                         case (QTI_LINEJACK):
7292                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7293                                 if (j->flags.g729_loaded)
7294                                         len += sprintf(buf + len, " w/G.729 A/B");
7295                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7296                                 break;
7297                         case (QTI_PHONEJACK_LITE):
7298                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7299                                 if (j->flags.g729_loaded)
7300                                         len += sprintf(buf + len, " w/G.729 A/B");
7301                                 break;
7302                         case (QTI_PHONEJACK_PCI):
7303                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7304                                 if (j->flags.g729_loaded)
7305                                         len += sprintf(buf + len, " w/G.729 A/B");
7306                                 break;
7307                         case (QTI_PHONECARD):
7308                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7309                                 if (j->flags.g729_loaded)
7310                                         len += sprintf(buf + len, " w/G.729 A/B");
7311                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7312                                 if (!j->pccr1.bits.drf)
7313                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7314                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7315                                 break;
7316                         default:
7317                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7318                                 break;
7319                         }
7320                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7321                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7322                         add_caps(j);
7323                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7324                         if (j->dsp.low != 0x20)
7325                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7326                         if (j->flags.cidsent)
7327                                 len += sprintf(buf + len, "\nCaller ID data sent");
7328                         else
7329                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7330
7331                         len += sprintf(buf + len, "\nPlay CODEC ");
7332                         switch (j->play_codec) {
7333                         case G723_63:
7334                                 len += sprintf(buf + len, "G.723.1 6.3");
7335                                 break;
7336                         case G723_53:
7337                                 len += sprintf(buf + len, "G.723.1 5.3");
7338                                 break;
7339                         case TS85:
7340                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7341                                 break;
7342                         case TS48:
7343                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7344                                 break;
7345                         case TS41:
7346                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7347                                 break;
7348                         case G728:
7349                                 len += sprintf(buf + len, "G.728");
7350                                 break;
7351                         case G729:
7352                                 len += sprintf(buf + len, "G.729");
7353                                 break;
7354                         case G729B:
7355                                 len += sprintf(buf + len, "G.729B");
7356                                 break;
7357                         case ULAW:
7358                                 len += sprintf(buf + len, "uLaw");
7359                                 break;
7360                         case ALAW:
7361                                 len += sprintf(buf + len, "aLaw");
7362                                 break;
7363                         case LINEAR16:
7364                                 len += sprintf(buf + len, "16 bit Linear");
7365                                 break;
7366                         case LINEAR8:
7367                                 len += sprintf(buf + len, "8 bit Linear");
7368                                 break;
7369                         case WSS:
7370                                 len += sprintf(buf + len, "Windows Sound System");
7371                                 break;
7372                         default:
7373                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7374                                 break;
7375                         }
7376                         len += sprintf(buf + len, "\nRecord CODEC ");
7377                         switch (j->rec_codec) {
7378                         case G723_63:
7379                                 len += sprintf(buf + len, "G.723.1 6.3");
7380                                 break;
7381                         case G723_53:
7382                                 len += sprintf(buf + len, "G.723.1 5.3");
7383                                 break;
7384                         case TS85:
7385                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7386                                 break;
7387                         case TS48:
7388                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7389                                 break;
7390                         case TS41:
7391                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7392                                 break;
7393                         case G728:
7394                                 len += sprintf(buf + len, "G.728");
7395                                 break;
7396                         case G729:
7397                                 len += sprintf(buf + len, "G.729");
7398                                 break;
7399                         case G729B:
7400                                 len += sprintf(buf + len, "G.729B");
7401                                 break;
7402                         case ULAW:
7403                                 len += sprintf(buf + len, "uLaw");
7404                                 break;
7405                         case ALAW:
7406                                 len += sprintf(buf + len, "aLaw");
7407                                 break;
7408                         case LINEAR16:
7409                                 len += sprintf(buf + len, "16 bit Linear");
7410                                 break;
7411                         case LINEAR8:
7412                                 len += sprintf(buf + len, "8 bit Linear");
7413                                 break;
7414                         case WSS:
7415                                 len += sprintf(buf + len, "Windows Sound System");
7416                                 break;
7417                         default:
7418                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7419                                 break;
7420                         }
7421                         len += sprintf(buf + len, "\nAEC ");
7422                         switch (j->aec_level) {
7423                         case AEC_OFF:
7424                                 len += sprintf(buf + len, "Off");
7425                                 break;
7426                         case AEC_LOW:
7427                                 len += sprintf(buf + len, "Low");
7428                                 break;
7429                         case AEC_MED:
7430                                 len += sprintf(buf + len, "Med");
7431                                 break;
7432                         case AEC_HIGH:
7433                                 len += sprintf(buf + len, "High");
7434                                 break;
7435                         case AEC_AUTO:
7436                                 len += sprintf(buf + len, "Auto");
7437                                 break;
7438                         case AEC_AGC:
7439                                 len += sprintf(buf + len, "AEC/AGC");
7440                                 break;
7441                         default:
7442                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7443                                 break;
7444                         }
7445
7446                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7447                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7448                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7449
7450                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7451
7452                         if (j->cardtype == QTI_LINEJACK) {
7453                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7454                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7455                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7456                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7457                                 switch (j->daa_mode) {
7458                                 case SOP_PU_SLEEP:
7459                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7460                                         break;
7461                                 case SOP_PU_RINGING:
7462                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7463                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7464                                         break;
7465                                 case SOP_PU_CONVERSATION:
7466                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7467                                         break;
7468                                 case SOP_PU_PULSEDIALING:
7469                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7470                                         break;
7471                                 }
7472                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7473                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7474                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7475                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7476                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7477                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7478                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7479                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7480                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7481                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7482                         }
7483                         switch (j->port) {
7484                         case PORT_POTS:
7485                                 len += sprintf(buf + len, "\nPort POTS");
7486                                 break;
7487                         case PORT_PSTN:
7488                                 len += sprintf(buf + len, "\nPort PSTN");
7489                                 break;
7490                         case PORT_SPEAKER:
7491                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7492                                 break;
7493                         case PORT_HANDSET:
7494                                 len += sprintf(buf + len, "\nPort HANDSET");
7495                                 break;
7496                         }
7497                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7498                                 len += sprintf(buf + len, "\nSLIC state ");
7499                                 switch (SLIC_GetState(j)) {
7500                                 case PLD_SLIC_STATE_OC:
7501                                         len += sprintf(buf + len, "OC");
7502                                         break;
7503                                 case PLD_SLIC_STATE_RINGING:
7504                                         len += sprintf(buf + len, "RINGING");
7505                                         break;
7506                                 case PLD_SLIC_STATE_ACTIVE:
7507                                         len += sprintf(buf + len, "ACTIVE");
7508                                         break;
7509                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7510                                         len += sprintf(buf + len, "OHT");
7511                                         break;
7512                                 case PLD_SLIC_STATE_TIPOPEN:
7513                                         len += sprintf(buf + len, "TIPOPEN");
7514                                         break;
7515                                 case PLD_SLIC_STATE_STANDBY:
7516                                         len += sprintf(buf + len, "STANDBY");
7517                                         break;
7518                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7519                                         len += sprintf(buf + len, "APR");
7520                                         break;
7521                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7522                                         len += sprintf(buf + len, "OHTPR");
7523                                         break;
7524                                 default:
7525                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7526                                         break;
7527                                 }
7528                         }
7529                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7530                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7531 #ifdef PERFMON_STATS
7532                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7533                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7534                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7535                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7536                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7537                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7538                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7539                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7540                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7541                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7542                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7543                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7544                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7545                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7546
7547 #endif
7548                         len += sprintf(buf + len, "\n");
7549                 }
7550         }
7551         return len;
7552 }
7553
7554 static int ixj_read_proc(char *page, char **start, off_t off,
7555                               int count, int *eof, void *data)
7556 {
7557         int len = ixj_get_status_proc(page);
7558         if (len <= off+count) *eof = 1;
7559         *start = page + off;
7560         len -= off;
7561         if (len>count) len = count;
7562         if (len<0) len = 0;
7563         return len;
7564 }
7565
7566
7567 static void cleanup(void)
7568 {
7569         int cnt;
7570         IXJ *j;
7571
7572         for (cnt = 0; cnt < IXJMAX; cnt++) {
7573                 j = get_ixj(cnt);
7574                 if(j != NULL && j->DSPbase) {
7575                         if (ixjdebug & 0x0002)
7576                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7577                         del_timer(&j->timer);
7578                         if (j->cardtype == QTI_LINEJACK) {
7579                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7580
7581                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7582                                 j->pld_slicw.bits.rly1 = 0;
7583                                 j->pld_slicw.bits.rly2 = 0;
7584                                 j->pld_slicw.bits.rly3 = 0;
7585                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7586                                 LED_SetState(0x0, j);
7587                                 if (ixjdebug & 0x0002)
7588                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7589                                 release_region(j->XILINXbase, 8);
7590                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7591                                 if (ixjdebug & 0x0002)
7592                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7593                                 release_region(j->XILINXbase, 4);
7594                         }
7595                         if (j->read_buffer)
7596                                 kfree(j->read_buffer);
7597                         if (j->write_buffer)
7598                                 kfree(j->write_buffer);
7599                         if (j->dev)
7600                                 pnp_device_detach(j->dev);
7601                         if (ixjdebug & 0x0002)
7602                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7603                         phone_unregister_device(&j->p);
7604                         if (ixjdebug & 0x0002)
7605                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7606                         release_region(j->DSPbase, 16);
7607 #ifdef IXJ_DYN_ALLOC
7608                         if (ixjdebug & 0x0002)
7609                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7610                         kfree(j);
7611                         ixj[cnt] = NULL;
7612 #endif
7613                 }
7614         }
7615         if (ixjdebug & 0x0002)
7616                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7617         remove_proc_entry ("ixj", NULL);
7618 }
7619
7620 /* Typedefs */
7621 typedef struct {
7622         BYTE length;
7623         DWORD bits;
7624 } DATABLOCK;
7625
7626 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7627 {
7628         lastLCC = lastLCC & 0xfb;
7629         lastLCC = lastLCC | (byData ? 4 : 0);
7630         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7631
7632         mdelay(1);
7633         lastLCC = lastLCC | 0x01;
7634         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7635
7636         byData = byData << 1;
7637         lastLCC = lastLCC & 0xfe;
7638         mdelay(1);
7639         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7640
7641 }
7642
7643 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7644 {
7645         mdelay(1);
7646         lastLCC = lastLCC | 0x01;
7647         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7648
7649         lastLCC = lastLCC & 0xfe;
7650         mdelay(1);
7651         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7652
7653         return ((inb(wEEPROMAddress) >> 3) & 1);
7654 }
7655
7656 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7657 {
7658         BYTE lastLCC;
7659         WORD wEEPROMAddress = wAddress + 3;
7660         DWORD i;
7661         BYTE byResult;
7662         *pwResult = 0;
7663         lastLCC = inb(wEEPROMAddress);
7664         lastLCC = lastLCC | 0x02;
7665         lastLCC = lastLCC & 0xfe;
7666         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7667
7668         mdelay(1);              /* delay */
7669
7670         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7671         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7672         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7673         for (i = 0; i < 8; i++) {
7674                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7675                 wLoc <<= 1;
7676         }
7677
7678         for (i = 0; i < 16; i++) {
7679                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7680                 *pwResult = (*pwResult << 1) | byResult;
7681         }
7682
7683         mdelay(1);              /* another delay */
7684
7685         lastLCC = lastLCC & 0xfd;
7686         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7687
7688         return 0;
7689 }
7690
7691 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7692 {
7693         WORD wLo, wHi;
7694         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7695                 return 0;
7696         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7697                 return 0;
7698         return (((DWORD) wHi << 16) | wLo);
7699 }
7700
7701 static int dspio[IXJMAX + 1] =
7702 {
7703         0,
7704 };
7705 static int xio[IXJMAX + 1] =
7706 {
7707         0,
7708 };
7709
7710 MODULE_PARM(dspio, "1-" __MODULE_STRING(IXJMAX) "i");
7711 MODULE_PARM(xio, "1-" __MODULE_STRING(IXJMAX) "i");
7712 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7713 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7714 MODULE_LICENSE("GPL");
7715
7716 static void __exit ixj_exit(void)
7717 {
7718         cleanup();
7719 }
7720
7721 int __init ixj_probe_isapnp(int *cnt)
7722 {
7723         int probe = 0;
7724         int func = 0x110;
7725         struct pnp_dev *dev = NULL, *old_dev = NULL;
7726
7727         while (1) {
7728                 do {
7729                         IXJ *j;
7730                         int result;
7731
7732                         old_dev = dev;
7733                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7734                                          ISAPNP_FUNCTION(func), old_dev);
7735                         if (!dev || !dev->card)
7736                                 break;
7737                         result = pnp_device_attach(dev);
7738                         if (result < 0) {
7739                                 printk("pnp attach failed %d \n", result);
7740                                 break;
7741                         }
7742                         if (pnp_activate_dev(dev) < 0) {
7743                                 printk("pnp activate failed (out of resources?)\n");
7744                                 pnp_device_detach(dev);
7745                                 return -ENOMEM;
7746                         }
7747
7748                         if (!pnp_port_valid(dev, 0)) {
7749                                 pnp_device_detach(dev);
7750                                 return -ENODEV;
7751                         }
7752
7753                         result = check_region(pnp_port_start(dev, 0), 16);
7754                         if (result) {
7755                                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", pnp_port_start(dev, 0));
7756                                 break;
7757                         }
7758
7759                         j = ixj_alloc();
7760                         j->DSPbase = pnp_port_start(dev,0);
7761                         request_region(j->DSPbase, 16, "ixj DSP");
7762
7763                         if (func != 0x110)
7764                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7765
7766                         switch (func) {
7767                         case (0x110):
7768                                 j->cardtype = QTI_PHONEJACK;
7769                                 break;
7770                         case (0x310):
7771                                 j->cardtype = QTI_LINEJACK;
7772                                 break;
7773                         case (0x410):
7774                                 j->cardtype = QTI_PHONEJACK_LITE;
7775                                 break;
7776                         }
7777                         j->board = *cnt;
7778                         probe = ixj_selfprobe(j);
7779                         if(!probe) {
7780                                 j->serial = dev->card->serial;
7781                                 j->dev = dev;
7782                                 switch (func) {
7783                                 case 0x110:
7784                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7785                                         break;
7786                                 case 0x310:
7787                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7788                                         break;
7789                                 case 0x410:
7790                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7791                                         break;
7792                                 }
7793                         }
7794                         ++*cnt;
7795                 } while (dev);
7796                 if (func == 0x410)
7797                         break;
7798                 if (func == 0x310)
7799                         func = 0x410;
7800                 if (func == 0x110)
7801                         func = 0x310;
7802                 dev = NULL;
7803         }
7804         return probe;
7805 }
7806
7807 int __init ixj_probe_isa(int *cnt)
7808 {
7809         int i, result, probe;
7810
7811         /* Use passed parameters for older kernels without PnP */
7812         for (i = 0; i < IXJMAX; i++) {
7813                 if (dspio[i]) {
7814                         IXJ *j;
7815
7816                         if ((result = check_region(ixj[*cnt].DSPbase, 16)) < 0) {
7817                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", ixj[*cnt].DSPbase);
7818                                 break;
7819                         }
7820
7821                         j = ixj_alloc();
7822
7823                         j->DSPbase = dspio[i];
7824                         request_region(j->DSPbase, 16, "ixj DSP");
7825
7826                         j->XILINXbase = xio[i];
7827                         j->cardtype = 0;
7828
7829                         j->board = *cnt;
7830                         probe = ixj_selfprobe(j);
7831                         j->dev = NULL;
7832                         ++*cnt;
7833                 }
7834         }
7835         return 0;
7836 }
7837
7838 int __init ixj_probe_pci(int *cnt)
7839 {
7840         struct pci_dev *pci = NULL;
7841         int i, probe = 0;
7842         IXJ *j = NULL;
7843         int result;
7844
7845         for (i = 0; i < IXJMAX - *cnt; i++) {
7846                 pci = pci_find_device(0x15E2, 0x0500, pci);
7847                 if (!pci)
7848                         break;
7849
7850                 if (pci_enable_device(pci))
7851                         break;
7852                 if ((result = check_region(pci_resource_start(pci, 0), 16)) < 0) {
7853                         printk(KERN_INFO "ixj: can't get I/O address\n");
7854                         break;
7855                 }
7856
7857                 /* Grab a device slot */
7858                 j = ixj_alloc();
7859                 if(j == NULL)
7860                         break;
7861
7862                 j->DSPbase = pci_resource_start(pci, 0);
7863                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7864                 j->XILINXbase = j->DSPbase + 0x10;
7865                 request_region(j->DSPbase, 16, "ixj DSP");
7866                 j->cardtype = QTI_PHONEJACK_PCI;
7867                 j->board = *cnt;
7868                 probe = ixj_selfprobe(j);
7869                 if (!probe)
7870                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7871                 ++*cnt;
7872         }
7873         return probe;
7874 }
7875
7876 static int __init ixj_init(void)
7877 {
7878         int cnt = 0;
7879         int probe = 0;
7880
7881         cnt = 0;
7882
7883         /* These might be no-ops, see above. */
7884         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7885                 return probe;
7886         }
7887         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7888                 return probe;
7889         }
7890         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7891                 return probe;
7892         }
7893         printk("%s\n", ixj_c_rcsid);
7894         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7895         return probe;
7896 }
7897
7898 module_init(ixj_init);
7899 module_exit(ixj_exit);
7900
7901 static void DAA_Coeff_US(IXJ *j)
7902 {
7903         int i;
7904
7905         j->daa_country = DAA_US;
7906         /*----------------------------------------------- */
7907         /* CAO */
7908         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7909                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7910         }
7911
7912 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7913         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7914         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7915         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7916         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7917         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7918         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7919         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7920         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7921 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7922         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7923         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7924         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7925         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7926         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7927         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7928         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7929         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7930 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7931         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7932         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7933         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7934         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7935         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7936         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7937         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7938         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7939 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7940         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7941         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7942         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7943         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7944         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7945         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7946         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7947         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7948 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7949         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7950         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7951         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7952         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7953 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7954         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7955         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7956         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7957         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7958 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7959         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7960         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7961         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7962         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7963         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7964         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7965         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7966         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7967 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7968         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7969         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7970         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7971         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7972         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7973         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7974         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7975         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7976 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7977         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7978         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7979         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7980         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7981         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7982         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7983         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7984         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7985 /* ;  (10K, 0.68uF) */
7986         /*  */
7987         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7988         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7989         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7990         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7991         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7992         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7993         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7994         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7995         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7996         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7997         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7998         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7999         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8000         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8001         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8002         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8003         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8004         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8005
8006         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8007         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8008         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8009         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8010         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8011
8012         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8013 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
8014 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
8015 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
8016 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
8017 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
8018 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
8019 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
8020 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
8021         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8022 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
8023 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
8024 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
8025 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
8026 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
8027 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
8028 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
8029 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
8030 /* */
8031         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8032 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
8033 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
8034 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
8035 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
8036
8037         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8038         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8039         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8040         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8041         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8042         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8043         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8044         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8045         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8046 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8047         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8048         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8049         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8050         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8051         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8052         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8053         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8054         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8055 /*  */
8056         /* ;CR Registers */
8057         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
8058         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8059 /* Config. Reg. 1 (dialing)       (cr1):05 */
8060         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8061 /* Config. Reg. 2 (caller ID)     (cr2):04 */
8062         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8063 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
8064         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8065 /* Config. Reg. 4 (analog gain)   (cr4):02 */
8066         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8067         /* Config. Reg. 5 (Version)       (cr5):02 */
8068         /* Config. Reg. 6 (Reserved)      (cr6):00 */
8069         /* Config. Reg. 7 (Reserved)      (cr7):00 */
8070         /*  */
8071         /* ;xr Registers */
8072         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
8073
8074         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8075         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
8076
8077         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
8078 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8079         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8080 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
8081         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
8082         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
8083
8084         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8085 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
8086         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8087 /* Ext. Reg. 6 (Power State)      (xr6):00 */
8088         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8089 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
8090         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8091         /*  */
8092         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
8093         /*                                       12,33,5A,C3 ;  770 Hz   */
8094         /*                                       13,3C,5B,32 ;  852 Hz   */
8095         /*                                       1D,1B,5C,CC ;  941 Hz   */
8096
8097         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8098         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8099         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8100         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8101 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
8102         /*                                       EC,1D,52,22 ;  1336 Hz   */
8103         /*                                       AA,AC,51,D2 ;  1477 Hz   */
8104         /*                                       9B,3B,51,25 ;  1633 Hz   */
8105         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8106         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8107         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8108         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8109 }
8110
8111 static void DAA_Coeff_UK(IXJ *j)
8112 {
8113         int i;
8114
8115         j->daa_country = DAA_UK;
8116         /*----------------------------------------------- */
8117         /* CAO */
8118         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8119                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8120         }
8121
8122 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8123         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8124         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8125         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8126         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8127         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8128         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8129         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8130         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8131 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8132         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8133         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8134         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8135         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8136         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8137         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8138         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8139         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8140 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
8141         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8142         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8143         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8144         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8145         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8146         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8147         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8148         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8149 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8150         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8151         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8152         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8153         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8154         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8155         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8156         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8157         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8158 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8159         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8160         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8161         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8162         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8163 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8164         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8165         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8166         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8167         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8168 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8169         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8170         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8171         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8172         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8173         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8174         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8175         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8176         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8177 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8178         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8179         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8180         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8181         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8182         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8183         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8184         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8185         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8186 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8187         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8188         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8189         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8190         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8191         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8192         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8193         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8194         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8195 /* ; idle */
8196         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8197         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8198         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8199         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8200         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8201         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8202         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8203         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8204         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8205 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8206         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8207         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8208         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8209         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8210         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8211         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8212         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8213         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8214 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8215         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8216         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8217         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8218         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8219 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8220         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8221         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8222         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8223         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8224         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8225         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8226         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8227         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8228 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8229         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8230         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8231         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8232         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8233         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8234         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8235         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8236         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8237 /* ;CR Registers */
8238         /* Config. Reg. 0 (filters)        (cr0):FF */
8239         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8240 /* Config. Reg. 1 (dialing)        (cr1):05 */
8241         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8242 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8243         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8244 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8245         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8246 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8247         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8248         /* Config. Reg. 5 (Version)        (cr5):02 */
8249         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8250         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8251         /* ;xr Registers */
8252         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8253
8254         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8255         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8256
8257         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8258         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8259
8260         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8261 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8262         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8263 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8264         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8265 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8266         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8267 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8268         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8269 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8270         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8271         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8272         /*                                       12,33,5A,C3    ;  770 Hz   */
8273         /*                                       13,3C,5B,32    ;  852 Hz   */
8274         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8275
8276         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8277         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8278         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8279         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8280 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8281         /*                                       EC,1D,52,22    ;  1336 Hz   */
8282         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8283         /*                                       9B,3B,51,25    ;  1633 Hz   */
8284         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8285         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8286         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8287         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8288 }
8289
8290
8291 static void DAA_Coeff_France(IXJ *j)
8292 {
8293         int i;
8294
8295         j->daa_country = DAA_FRANCE;
8296         /*----------------------------------------------- */
8297         /* CAO */
8298         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8299                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8300         }
8301
8302 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8303         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8304         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8305         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8306         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8307         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8308         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8309         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8310         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8311 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8312         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8313         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8314         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8315         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8316         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8317         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8318         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8319         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8320 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8321         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8322         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8323         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8324         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8325         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8326         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8327         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8328         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8329 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8330         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8331         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8332         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8333         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8334         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8335         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8336         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8337         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8338 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8339         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8340         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8341         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8342         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8343 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8344         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8345         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8346         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8347         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8348 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8349         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8350         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8351         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8352         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8353         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8354         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8355         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8356         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8357 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8358         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8359         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8360         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8361         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8362         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8363         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8364         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8365         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8366 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8367         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8368         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8369         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8370         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8371         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8372         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8373         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8374         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8375 /* ; idle */
8376         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8377         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8378         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8379         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8380         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8381         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8382         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8383         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8384         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8385 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8386         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8387         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8388         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8389         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8390         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8391         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8392         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8393         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8394 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8395         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8396         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8397         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8398         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8399 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8400         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8401         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8402         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8403         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8404         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8405         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8406         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8407         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8408 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8409         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8410         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8411         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8412         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8413         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8414         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8415         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8416         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8417 /* ;CR Registers */
8418         /* Config. Reg. 0 (filters)        (cr0):FF */
8419         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8420 /* Config. Reg. 1 (dialing)        (cr1):05 */
8421         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8422 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8423         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8424 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8425         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8426 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8427         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8428         /* Config. Reg. 5 (Version)        (cr5):02 */
8429         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8430         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8431         /* ;xr Registers */
8432         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8433
8434         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8435         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8436
8437         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8438         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8439
8440         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8441 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8442         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8443 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8444         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8445 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8446         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8447 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8448         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8449 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8450         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8451         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8452         /*                                       12,33,5A,C3    ;  770 Hz   */
8453         /*                                       13,3C,5B,32    ;  852 Hz   */
8454         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8455
8456         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8457         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8458         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8459         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8460 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8461         /*                                       EC,1D,52,22    ;  1336 Hz   */
8462         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8463         /*                                       9B,3B,51,25    ;  1633 Hz   */
8464         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8465         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8466         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8467         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8468 }
8469
8470
8471 static void DAA_Coeff_Germany(IXJ *j)
8472 {
8473         int i;
8474
8475         j->daa_country = DAA_GERMANY;
8476         /*----------------------------------------------- */
8477         /* CAO */
8478         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8479                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8480         }
8481
8482 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8483         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8484         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8485         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8486         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8487         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8488         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8489         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8490         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8491 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8492         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8493         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8494         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8495         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8496         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8497         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8498         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8499         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8500 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8501         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8502         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8503         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8504         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8505         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8506         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8507         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8508         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8509 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8510         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8511         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8512         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8513         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8514         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8515         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8516         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8517         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8518 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8519         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8520         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8521         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8522         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8523 /* Bytes for AR-filter        (09): 72,42,13,4B */
8524         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8525         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8526         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8527         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8528 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8529         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8530         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8531         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8532         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8533         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8534         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8535         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8536         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8537 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8538         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8539         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8540         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8541         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8542         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8543         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8544         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8545         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8546 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8547         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8548         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8549         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8550         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8551         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8552         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8553         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8554         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8555 /* ;  (10K, 0.68uF) */
8556         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8557         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8558         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8559         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8560         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8561         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8562         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8563         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8564         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8565 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8566         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8567         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8568         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8569         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8570         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8571         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8572         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8573         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8574 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8575         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8576         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8577         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8578         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8579 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8580         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8581         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8582         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8583         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8584         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8585         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8586         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8587         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8588 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8589         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8590         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8591         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8592         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8593         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8594         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8595         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8596         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8597 /* ;CR Registers */
8598         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8599         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8600 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8601         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8602 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8603         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8604 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8605         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8606 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8607         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8608         /* Config. Reg. 5 (Version)        (cr5):02 */
8609         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8610         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8611         /* ;xr Registers */
8612         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8613
8614         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8615         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8616
8617         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8618         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8619
8620         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8621 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8622         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8623 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8624         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8625 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8626         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8627 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8628         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8629 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8630         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8631         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8632         /*                                       12,33,5A,C3    ;  770 Hz   */
8633         /*                                       13,3C,5B,32    ;  852 Hz   */
8634         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8635
8636         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8637         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8638         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8639         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8640 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8641         /*                                       EC,1D,52,22    ;  1336 Hz   */
8642         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8643         /*                                       9B,3B,51,25    ;  1633 Hz   */
8644         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8645         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8646         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8647         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8648 }
8649
8650
8651 static void DAA_Coeff_Australia(IXJ *j)
8652 {
8653         int i;
8654
8655         j->daa_country = DAA_AUSTRALIA;
8656         /*----------------------------------------------- */
8657         /* CAO */
8658         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8659                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8660         }
8661
8662 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8663         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8664         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8665         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8666         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8667         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8668         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8669         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8670         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8671 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8672         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8673         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8674         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8675         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8676         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8677         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8678         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8679         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8680 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8681         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8682         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8683         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8684         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8685         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8686         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8687         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8688         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8689 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8690         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8691         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8692         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8693         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8694         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8695         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8696         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8697         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8698 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8699         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8700         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8701         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8702         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8703 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8704         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8705         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8706         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8707         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8708 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8709         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8710         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8711         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8712         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8713         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8714         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8715         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8716         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8717 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8718         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8719         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8720         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8721         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8722         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8723         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8724         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8725         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8726 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8727         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8728         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8729         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8730         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8731         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8732         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8733         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8734         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8735 /* ;  idle */
8736         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8737         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8738         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8739         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8740         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8741         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8742         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8743         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8744         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8745 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8746         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8747         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8748         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8749         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8750         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8751         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8752         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8753         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8754 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8755         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8756         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8757         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8758         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8759 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8760         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8761         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8762         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8763         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8764         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8765         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8766         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8767         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8768 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8769         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8770         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8771         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8772         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8773         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8774         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8775         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8776         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8777 /* ;CR Registers */
8778         /* Config. Reg. 0 (filters)        (cr0):FF */
8779         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8780 /* Config. Reg. 1 (dialing)        (cr1):05 */
8781         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8782 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8783         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8784 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8785         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8786 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8787         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8788         /* Config. Reg. 5 (Version)        (cr5):02 */
8789         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8790         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8791         /* ;xr Registers */
8792         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8793
8794         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8795         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8796
8797         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8798         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8799
8800         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8801 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8802         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8803 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8804         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8805 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8806         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8807 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8808         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8809 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8810         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8811
8812         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8813         /*                                       12,33,5A,C3    ;  770 Hz   */
8814         /*                                       13,3C,5B,32    ;  852 Hz   */
8815         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8816         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8817         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8818         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8819         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8820
8821         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8822         /*                                       EC,1D,52,22    ;  1336 Hz   */
8823         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8824         /*                                       9B,3B,51,25    ;  1633 Hz   */
8825         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8826         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8827         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8828         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8829 }
8830
8831 static void DAA_Coeff_Japan(IXJ *j)
8832 {
8833         int i;
8834
8835         j->daa_country = DAA_JAPAN;
8836         /*----------------------------------------------- */
8837         /* CAO */
8838         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8839                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8840         }
8841
8842 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8843         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8844         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8845         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8846         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8847         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8848         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8849         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8850         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8851 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8852         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8853         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8854         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8855         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8856         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8857         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8858         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8859         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8860 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8861         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8862         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8863         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8864         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8865         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8866         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8867         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8868         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8869 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8870         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8871         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8872         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8873         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8874         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8875         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8876         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8877         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8878 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8879         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8880         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8881         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8882         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8883 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8884         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8885         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8886         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8887         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8888 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8889         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8890         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8891         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8892         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8893         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8894         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8895         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8896         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8897 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8898         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8899         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8900         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8901         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8902         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8903         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8904         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8905         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8906 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8907         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8908         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8909         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8910         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8911         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8912         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8913         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8914         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8915 /* ;  idle */
8916         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8917         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8918         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8919         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8920         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8921         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8922         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8923         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8924         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8925 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8926         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8927         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8928         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8929         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8930         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8931         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8932         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8933         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8934 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8935         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8936         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8937         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8938         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8939 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8940         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8941         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8942         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8943         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8944         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8945         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8946         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8947         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8948 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8949         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8950         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8951         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8952         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8953         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8954         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8955         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8956         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8957 /* ;CR Registers */
8958         /* Config. Reg. 0 (filters)        (cr0):FF */
8959         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8960 /* Config. Reg. 1 (dialing)        (cr1):05 */
8961         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8962 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8963         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8964 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8965         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8966 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8967         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8968         /* Config. Reg. 5 (Version)        (cr5):02 */
8969         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8970         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8971         /* ;xr Registers */
8972         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8973
8974         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8975         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8976
8977         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8978         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8979
8980         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8981 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8982         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8983 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8984         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8985 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8986         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8987 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8988         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8989 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8990         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8991         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8992         /*                                       12,33,5A,C3    ;  770 Hz   */
8993         /*                                       13,3C,5B,32    ;  852 Hz   */
8994         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8995
8996         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8997         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8998         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8999         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
9000 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
9001         /*                                       EC,1D,52,22    ;  1336 Hz   */
9002         /*                                       AA,AC,51,D2    ;  1477 Hz   */
9003         /*                                       9B,3B,51,25    ;  1633 Hz   */
9004         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
9005         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
9006         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
9007         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
9008 }
9009
9010 static s16 tone_table[][19] =
9011 {
9012         {                       /* f20_50[] 11 */
9013                 32538,          /* A1 = 1.985962 */
9014                  -32325,        /* A2 = -0.986511 */
9015                  -343,          /* B2 = -0.010493 */
9016                  0,             /* B1 = 0 */
9017                  343,           /* B0 = 0.010493 */
9018                  32619,         /* A1 = 1.990906 */
9019                  -32520,        /* A2 = -0.992462 */
9020                  19179,         /* B2 = 0.585327 */
9021                  -19178,        /* B1 = -1.170593 */
9022                  19179,         /* B0 = 0.585327 */
9023                  32723,         /* A1 = 1.997314 */
9024                  -32686,        /* A2 = -0.997528 */
9025                  9973,          /* B2 = 0.304352 */
9026                  -9955,         /* B1 = -0.607605 */
9027                  9973,          /* B0 = 0.304352 */
9028                  7,             /* Internal filter scaling */
9029                  159,           /* Minimum in-band energy threshold */
9030                  21,            /* 21/32 in-band to broad-band ratio */
9031                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9032         },
9033         {                       /* f133_200[] 12 */
9034                 32072,          /* A1 = 1.95752 */
9035                  -31896,        /* A2 = -0.973419 */
9036                  -435,          /* B2 = -0.013294 */
9037                  0,             /* B1 = 0 */
9038                  435,           /* B0 = 0.013294 */
9039                  32188,         /* A1 = 1.9646 */
9040                  -32400,        /* A2 = -0.98877 */
9041                  15139,         /* B2 = 0.462036 */
9042                  -14882,        /* B1 = -0.908356 */
9043                  15139,         /* B0 = 0.462036 */
9044                  32473,         /* A1 = 1.981995 */
9045                  -32524,        /* A2 = -0.992584 */
9046                  23200,         /* B2 = 0.708008 */
9047                  -23113,        /* B1 = -1.410706 */
9048                  23200,         /* B0 = 0.708008 */
9049                  7,             /* Internal filter scaling */
9050                  159,           /* Minimum in-band energy threshold */
9051                  21,            /* 21/32 in-band to broad-band ratio */
9052                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9053         },
9054         {                       /* f300 13 */
9055                 31769,          /* A1 = -1.939026 */
9056                  -32584,        /* A2 = 0.994385 */
9057                  -475,          /* B2 = -0.014522 */
9058                  0,             /* B1 = 0.000000 */
9059                  475,           /* B0 = 0.014522 */
9060                  31789,         /* A1 = -1.940247 */
9061                  -32679,        /* A2 = 0.997284 */
9062                  17280,         /* B2 = 0.527344 */
9063                  -16865,        /* B1 = -1.029358 */
9064                  17280,         /* B0 = 0.527344 */
9065                  31841,         /* A1 = -1.943481 */
9066                  -32681,        /* A2 = 0.997345 */
9067                  543,           /* B2 = 0.016579 */
9068                  -525,          /* B1 = -0.032097 */
9069                  543,           /* B0 = 0.016579 */
9070                  5,             /* Internal filter scaling */
9071                  159,           /* Minimum in-band energy threshold */
9072                  21,            /* 21/32 in-band to broad-band ratio */
9073                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9074         },
9075         {                       /* f300_420[] 14 */
9076                 30750,          /* A1 = 1.876892 */
9077                  -31212,        /* A2 = -0.952515 */
9078                  -804,          /* B2 = -0.024541 */
9079                  0,             /* B1 = 0 */
9080                  804,           /* B0 = 0.024541 */
9081                  30686,         /* A1 = 1.872925 */
9082                  -32145,        /* A2 = -0.980988 */
9083                  14747,         /* B2 = 0.450043 */
9084                  -13703,        /* B1 = -0.836395 */
9085                  14747,         /* B0 = 0.450043 */
9086                  31651,         /* A1 = 1.931824 */
9087                  -32321,        /* A2 = -0.986389 */
9088                  24425,         /* B2 = 0.745422 */
9089                  -23914,        /* B1 = -1.459595 */
9090                  24427,         /* B0 = 0.745483 */
9091                  7,             /* Internal filter scaling */
9092                  159,           /* Minimum in-band energy threshold */
9093                  21,            /* 21/32 in-band to broad-band ratio */
9094                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9095         },
9096         {                       /* f330 15 */
9097                 31613,          /* A1 = -1.929565 */
9098                  -32646,        /* A2 = 0.996277 */
9099                  -185,          /* B2 = -0.005657 */
9100                  0,             /* B1 = 0.000000 */
9101                  185,           /* B0 = 0.005657 */
9102                  31620,         /* A1 = -1.929932 */
9103                  -32713,        /* A2 = 0.998352 */
9104                  19253,         /* B2 = 0.587585 */
9105                  -18566,        /* B1 = -1.133179 */
9106                  19253,         /* B0 = 0.587585 */
9107                  31674,         /* A1 = -1.933228 */
9108                  -32715,        /* A2 = 0.998413 */
9109                  2575,          /* B2 = 0.078590 */
9110                  -2495,         /* B1 = -0.152283 */
9111                  2575,          /* B0 = 0.078590 */
9112                  5,             /* Internal filter scaling */
9113                  159,           /* Minimum in-band energy threshold */
9114                  21,            /* 21/32 in-band to broad-band ratio */
9115                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9116         },
9117         {                       /* f300_425[] 16 */
9118                 30741,          /* A1 = 1.876282 */
9119                  -31475,        /* A2 = -0.960541 */
9120                  -703,          /* B2 = -0.021484 */
9121                  0,             /* B1 = 0 */
9122                  703,           /* B0 = 0.021484 */
9123                  30688,         /* A1 = 1.873047 */
9124                  -32248,        /* A2 = -0.984161 */
9125                  14542,         /* B2 = 0.443787 */
9126                  -13523,        /* B1 = -0.825439 */
9127                  14542,         /* B0 = 0.443817 */
9128                  31494,         /* A1 = 1.922302 */
9129                  -32366,        /* A2 = -0.987762 */
9130                  21577,         /* B2 = 0.658508 */
9131                  -21013,        /* B1 = -1.282532 */
9132                  21577,         /* B0 = 0.658508 */
9133                  7,             /* Internal filter scaling */
9134                  159,           /* Minimum in-band energy threshold */
9135                  21,            /* 21/32 in-band to broad-band ratio */
9136                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9137         },
9138         {                       /* f330_440[] 17 */
9139                 30627,          /* A1 = 1.869324 */
9140                  -31338,        /* A2 = -0.95636 */
9141                  -843,          /* B2 = -0.025749 */
9142                  0,             /* B1 = 0 */
9143                  843,           /* B0 = 0.025749 */
9144                  30550,         /* A1 = 1.864685 */
9145                  -32221,        /* A2 = -0.983337 */
9146                  13594,         /* B2 = 0.414886 */
9147                  -12589,        /* B1 = -0.768402 */
9148                  13594,         /* B0 = 0.414886 */
9149                  31488,         /* A1 = 1.921936 */
9150                  -32358,        /* A2 = -0.987518 */
9151                  24684,         /* B2 = 0.753296 */
9152                  -24029,        /* B1 = -1.466614 */
9153                  24684,         /* B0 = 0.753296 */
9154                  7,             /* Internal filter scaling */
9155                  159,           /* Minimum in-band energy threshold */
9156                  21,            /* 21/32 in-band to broad-band ratio */
9157                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9158         },
9159         {                       /* f340 18 */
9160                 31546,          /* A1 = -1.925476 */
9161                  -32646,        /* A2 = 0.996277 */
9162                  -445,          /* B2 = -0.013588 */
9163                  0,             /* B1 = 0.000000 */
9164                  445,           /* B0 = 0.013588 */
9165                  31551,         /* A1 = -1.925781 */
9166                  -32713,        /* A2 = 0.998352 */
9167                  23884,         /* B2 = 0.728882 */
9168                  -22979,        /* B1 = -1.402527 */
9169                  23884,         /* B0 = 0.728882 */
9170                  31606,         /* A1 = -1.929138 */
9171                  -32715,        /* A2 = 0.998413 */
9172                  863,           /* B2 = 0.026367 */
9173                  -835,          /* B1 = -0.050985 */
9174                  863,           /* B0 = 0.026367 */
9175                  5,             /* Internal filter scaling */
9176                  159,           /* Minimum in-band energy threshold */
9177                  21,            /* 21/32 in-band to broad-band ratio */
9178                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9179         },
9180         {                       /* f350_400[] 19 */
9181                 31006,          /* A1 = 1.892517 */
9182                  -32029,        /* A2 = -0.977448 */
9183                  -461,          /* B2 = -0.014096 */
9184                  0,             /* B1 = 0 */
9185                  461,           /* B0 = 0.014096 */
9186                  30999,         /* A1 = 1.892029 */
9187                  -32487,        /* A2 = -0.991455 */
9188                  11325,         /* B2 = 0.345612 */
9189                  -10682,        /* B1 = -0.651978 */
9190                  11325,         /* B0 = 0.345612 */
9191                  31441,         /* A1 = 1.919067 */
9192                  -32526,        /* A2 = -0.992615 */
9193                  24324,         /* B2 = 0.74231 */
9194                  -23535,        /* B1 = -1.436523 */
9195                  24324,         /* B0 = 0.74231 */
9196                  7,             /* Internal filter scaling */
9197                  159,           /* Minimum in-band energy threshold */
9198                  21,            /* 21/32 in-band to broad-band ratio */
9199                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9200         },
9201         {                       /* f350_440[] */
9202                 30634,          /* A1 = 1.869751 */
9203                  -31533,        /* A2 = -0.962341 */
9204                  -680,          /* B2 = -0.020782 */
9205                  0,             /* B1 = 0 */
9206                  680,           /* B0 = 0.020782 */
9207                  30571,         /* A1 = 1.865906 */
9208                  -32277,        /* A2 = -0.985016 */
9209                  12894,         /* B2 = 0.393524 */
9210                  -11945,        /* B1 = -0.729065 */
9211                  12894,         /* B0 = 0.393524 */
9212                  31367,         /* A1 = 1.91449 */
9213                  -32379,        /* A2 = -0.988129 */
9214                  23820,         /* B2 = 0.726929 */
9215                  -23104,        /* B1 = -1.410217 */
9216                  23820,         /* B0 = 0.726929 */
9217                  7,             /* Internal filter scaling */
9218                  159,           /* Minimum in-band energy threshold */
9219                  21,            /* 21/32 in-band to broad-band ratio */
9220                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9221         },
9222         {                       /* f350_450[] */
9223                 30552,          /* A1 = 1.864807 */
9224                  -31434,        /* A2 = -0.95929 */
9225                  -690,          /* B2 = -0.021066 */
9226                  0,             /* B1 = 0 */
9227                  690,           /* B0 = 0.021066 */
9228                  30472,         /* A1 = 1.859924 */
9229                  -32248,        /* A2 = -0.984161 */
9230                  13385,         /* B2 = 0.408478 */
9231                  -12357,        /* B1 = -0.754242 */
9232                  13385,         /* B0 = 0.408478 */
9233                  31358,         /* A1 = 1.914001 */
9234                  -32366,        /* A2 = -0.987732 */
9235                  26488,         /* B2 = 0.80835 */
9236                  -25692,        /* B1 = -1.568176 */
9237                  26490,         /* B0 = 0.808411 */
9238                  7,             /* Internal filter scaling */
9239                  159,           /* Minimum in-band energy threshold */
9240                  21,            /* 21/32 in-band to broad-band ratio */
9241                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9242         },
9243         {                       /* f360 */
9244                 31397,          /* A1 = -1.916321 */
9245                  -32623,        /* A2 = 0.995605 */
9246                  -117,          /* B2 = -0.003598 */
9247                  0,             /* B1 = 0.000000 */
9248                  117,           /* B0 = 0.003598 */
9249                  31403,         /* A1 = -1.916687 */
9250                  -32700,        /* A2 = 0.997925 */
9251                  3388,          /* B2 = 0.103401 */
9252                  -3240,         /* B1 = -0.197784 */
9253                  3388,          /* B0 = 0.103401 */
9254                  31463,         /* A1 = -1.920410 */
9255                  -32702,        /* A2 = 0.997986 */
9256                  13346,         /* B2 = 0.407288 */
9257                  -12863,        /* B1 = -0.785126 */
9258                  13346,         /* B0 = 0.407288 */
9259                  5,             /* Internal filter scaling */
9260                  159,           /* Minimum in-band energy threshold */
9261                  21,            /* 21/32 in-band to broad-band ratio */
9262                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9263         },
9264         {                       /* f380_420[] */
9265                 30831,          /* A1 = 1.881775 */
9266                  -32064,        /* A2 = -0.978546 */
9267                  -367,          /* B2 = -0.01122 */
9268                  0,             /* B1 = 0 */
9269                  367,           /* B0 = 0.01122 */
9270                  30813,         /* A1 = 1.880737 */
9271                  -32456,        /* A2 = -0.990509 */
9272                  11068,         /* B2 = 0.337769 */
9273                  -10338,        /* B1 = -0.631042 */
9274                  11068,         /* B0 = 0.337769 */
9275                  31214,         /* A1 = 1.905212 */
9276                  -32491,        /* A2 = -0.991577 */
9277                  16374,         /* B2 = 0.499695 */
9278                  -15781,        /* B1 = -0.963196 */
9279                  16374,         /* B0 = 0.499695 */
9280                  7,             /* Internal filter scaling */
9281                  159,           /* Minimum in-band energy threshold */
9282                  21,            /* 21/32 in-band to broad-band ratio */
9283                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9284         },
9285         {                       /* f392 */
9286                 31152,          /* A1 = -1.901428 */
9287                  -32613,        /* A2 = 0.995300 */
9288                  -314,          /* B2 = -0.009605 */
9289                  0,             /* B1 = 0.000000 */
9290                  314,           /* B0 = 0.009605 */
9291                  31156,         /* A1 = -1.901672 */
9292                  -32694,        /* A2 = 0.997742 */
9293                  28847,         /* B2 = 0.880371 */
9294                  -2734,         /* B1 = -0.166901 */
9295                  28847,         /* B0 = 0.880371 */
9296                  31225,         /* A1 = -1.905823 */
9297                  -32696,        /* A2 = 0.997803 */
9298                  462,           /* B2 = 0.014108 */
9299                  -442,          /* B1 = -0.027019 */
9300                  462,           /* B0 = 0.014108 */
9301                  5,             /* Internal filter scaling */
9302                  159,           /* Minimum in-band energy threshold */
9303                  21,            /* 21/32 in-band to broad-band ratio */
9304                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9305         },
9306         {                       /* f400_425[] */
9307                 30836,          /* A1 = 1.882141 */
9308                  -32296,        /* A2 = -0.985596 */
9309                  -324,          /* B2 = -0.009903 */
9310                  0,             /* B1 = 0 */
9311                  324,           /* B0 = 0.009903 */
9312                  30825,         /* A1 = 1.881409 */
9313                  -32570,        /* A2 = -0.993958 */
9314                  16847,         /* B2 = 0.51416 */
9315                  -15792,        /* B1 = -0.963898 */
9316                  16847,         /* B0 = 0.51416 */
9317                  31106,         /* A1 = 1.89856 */
9318                  -32584,        /* A2 = -0.994415 */
9319                  9579,          /* B2 = 0.292328 */
9320                  -9164,         /* B1 = -0.559357 */
9321                  9579,          /* B0 = 0.292328 */
9322                  7,             /* Internal filter scaling */
9323                  159,           /* Minimum in-band energy threshold */
9324                  21,            /* 21/32 in-band to broad-band ratio */
9325                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9326         },
9327         {                       /* f400_440[] */
9328                 30702,          /* A1 = 1.873962 */
9329                  -32134,        /* A2 = -0.980682 */
9330                  -517,          /* B2 = -0.015793 */
9331                  0,             /* B1 = 0 */
9332                  517,           /* B0 = 0.015793 */
9333                  30676,         /* A1 = 1.872375 */
9334                  -32520,        /* A2 = -0.992462 */
9335                  8144,          /* B2 = 0.24855 */
9336                  -7596,         /* B1 = -0.463684 */
9337                  8144,          /* B0 = 0.24855 */
9338                  31084,         /* A1 = 1.897217 */
9339                  -32547,        /* A2 = -0.993256 */
9340                  22713,         /* B2 = 0.693176 */
9341                  -21734,        /* B1 = -1.326599 */
9342                  22713,         /* B0 = 0.693176 */
9343                  7,             /* Internal filter scaling */
9344                  159,           /* Minimum in-band energy threshold */
9345                  21,            /* 21/32 in-band to broad-band ratio */
9346                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9347         },
9348         {                       /* f400_450[] */
9349                 30613,          /* A1 = 1.86853 */
9350                  -32031,        /* A2 = -0.977509 */
9351                  -618,          /* B2 = -0.018866 */
9352                  0,             /* B1 = 0 */
9353                  618,           /* B0 = 0.018866 */
9354                  30577,         /* A1 = 1.866272 */
9355                  -32491,        /* A2 = -0.991577 */
9356                  9612,          /* B2 = 0.293335 */
9357                  -8935,         /* B1 = -0.54541 */
9358                  9612,          /* B0 = 0.293335 */
9359                  31071,         /* A1 = 1.896484 */
9360                  -32524,        /* A2 = -0.992584 */
9361                  21596,         /* B2 = 0.659058 */
9362                  -20667,        /* B1 = -1.261414 */
9363                  21596,         /* B0 = 0.659058 */
9364                  7,             /* Internal filter scaling */
9365                  159,           /* Minimum in-band energy threshold */
9366                  21,            /* 21/32 in-band to broad-band ratio */
9367                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9368         },
9369         {                       /* f420 */
9370                 30914,          /* A1 = -1.886841 */
9371                  -32584,        /* A2 = 0.994385 */
9372                  -426,          /* B2 = -0.013020 */
9373                  0,             /* B1 = 0.000000 */
9374                  426,           /* B0 = 0.013020 */
9375                  30914,         /* A1 = -1.886841 */
9376                  -32679,        /* A2 = 0.997314 */
9377                  17520,         /* B2 = 0.534668 */
9378                  -16471,        /* B1 = -1.005310 */
9379                  17520,         /* B0 = 0.534668 */
9380                  31004,         /* A1 = -1.892334 */
9381                  -32683,        /* A2 = 0.997406 */
9382                  819,           /* B2 = 0.025023 */
9383                  -780,          /* B1 = -0.047619 */
9384                  819,           /* B0 = 0.025023 */
9385                  5,             /* Internal filter scaling */
9386                  159,           /* Minimum in-band energy threshold */
9387                  21,            /* 21/32 in-band to broad-band ratio */
9388                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9389         },
9390 #if 0
9391         {                       /* f425 */
9392                 30881,          /* A1 = -1.884827 */
9393                  -32603,        /* A2 = 0.994965 */
9394                  -496,          /* B2 = -0.015144 */
9395                  0,             /* B1 = 0.000000 */
9396                  496,           /* B0 = 0.015144 */
9397                  30880,         /* A1 = -1.884766 */
9398                  -32692,        /* A2 = 0.997711 */
9399                  24767,         /* B2 = 0.755859 */
9400                  -23290,        /* B1 = -1.421509 */
9401                  24767,         /* B0 = 0.755859 */
9402                  30967,         /* A1 = -1.890076 */
9403                  -32694,        /* A2 = 0.997772 */
9404                  728,           /* B2 = 0.022232 */
9405                  -691,          /* B1 = -0.042194 */
9406                  728,           /* B0 = 0.022232 */
9407                  5,             /* Internal filter scaling */
9408                  159,           /* Minimum in-band energy threshold */
9409                  21,            /* 21/32 in-band to broad-band ratio */
9410                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9411         },
9412 #else
9413         {
9414                 30850,
9415                 -32534,
9416                 -504,
9417                 0,
9418                 504,
9419                 30831,
9420                 -32669,
9421                 24303,
9422                 -22080,
9423                 24303,
9424                 30994,
9425                 -32673,
9426                 1905,
9427                 -1811,
9428                 1905,
9429                 5,
9430                 129,
9431                 17,
9432                 0xff5
9433         },
9434 #endif
9435         {                       /* f425_450[] */
9436                 30646,          /* A1 = 1.870544 */
9437                  -32327,        /* A2 = -0.986572 */
9438                  -287,          /* B2 = -0.008769 */
9439                  0,             /* B1 = 0 */
9440                  287,           /* B0 = 0.008769 */
9441                  30627,         /* A1 = 1.869324 */
9442                  -32607,        /* A2 = -0.995087 */
9443                  13269,         /* B2 = 0.404968 */
9444                  -12376,        /* B1 = -0.755432 */
9445                  13269,         /* B0 = 0.404968 */
9446                  30924,         /* A1 = 1.887512 */
9447                  -32619,        /* A2 = -0.995453 */
9448                  19950,         /* B2 = 0.608826 */
9449                  -18940,        /* B1 = -1.156006 */
9450                  19950,         /* B0 = 0.608826 */
9451                  7,             /* Internal filter scaling */
9452                  159,           /* Minimum in-band energy threshold */
9453                  21,            /* 21/32 in-band to broad-band ratio */
9454                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9455         },
9456         {                       /* f425_475[] */
9457                 30396,          /* A1 = 1.855225 */
9458                  -32014,        /* A2 = -0.97699 */
9459                  -395,          /* B2 = -0.012055 */
9460                  0,             /* B1 = 0 */
9461                  395,           /* B0 = 0.012055 */
9462                  30343,         /* A1 = 1.85199 */
9463                  -32482,        /* A2 = -0.991302 */
9464                  17823,         /* B2 = 0.543945 */
9465                  -16431,        /* B1 = -1.002869 */
9466                  17823,         /* B0 = 0.543945 */
9467                  30872,         /* A1 = 1.884338 */
9468                  -32516,        /* A2 = -0.99231 */
9469                  18124,         /* B2 = 0.553101 */
9470                  -17246,        /* B1 = -1.052673 */
9471                  18124,         /* B0 = 0.553101 */
9472                  7,             /* Internal filter scaling */
9473                  159,           /* Minimum in-band energy threshold */
9474                  21,            /* 21/32 in-band to broad-band ratio */
9475                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9476         },
9477         {                       /* f435 */
9478                 30796,          /* A1 = -1.879639 */
9479                  -32603,        /* A2 = 0.994965 */
9480                  -254,          /* B2 = -0.007762 */
9481                  0,             /* B1 = 0.000000 */
9482                  254,           /* B0 = 0.007762 */
9483                  30793,         /* A1 = -1.879456 */
9484                  -32692,        /* A2 = 0.997711 */
9485                  18934,         /* B2 = 0.577820 */
9486                  -17751,        /* B1 = -1.083496 */
9487                  18934,         /* B0 = 0.577820 */
9488                  30882,         /* A1 = -1.884888 */
9489                  -32694,        /* A2 = 0.997772 */
9490                  1858,          /* B2 = 0.056713 */
9491                  -1758,         /* B1 = -0.107357 */
9492                  1858,          /* B0 = 0.056713 */
9493                  5,             /* Internal filter scaling */
9494                  159,           /* Minimum in-band energy threshold */
9495                  21,            /* 21/32 in-band to broad-band ratio */
9496                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9497         },
9498         {                       /* f440_450[] */
9499                 30641,          /* A1 = 1.870239 */
9500                  -32458,        /* A2 = -0.99057 */
9501                  -155,          /* B2 = -0.004735 */
9502                  0,             /* B1 = 0 */
9503                  155,           /* B0 = 0.004735 */
9504                  30631,         /* A1 = 1.869568 */
9505                  -32630,        /* A2 = -0.995789 */
9506                  11453,         /* B2 = 0.349548 */
9507                  -10666,        /* B1 = -0.651001 */
9508                  11453,         /* B0 = 0.349548 */
9509                  30810,         /* A1 = 1.880554 */
9510                  -32634,        /* A2 = -0.995941 */
9511                  12237,         /* B2 = 0.373474 */
9512                  -11588,        /* B1 = -0.707336 */
9513                  12237,         /* B0 = 0.373474 */
9514                  7,             /* Internal filter scaling */
9515                  159,           /* Minimum in-band energy threshold */
9516                  21,            /* 21/32 in-band to broad-band ratio */
9517                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9518         },
9519         {                       /* f440_480[] */
9520                 30367,          /* A1 = 1.853455 */
9521                  -32147,        /* A2 = -0.981079 */
9522                  -495,          /* B2 = -0.015113 */
9523                  0,             /* B1 = 0 */
9524                  495,           /* B0 = 0.015113 */
9525                  30322,         /* A1 = 1.850769 */
9526                  -32543,        /* A2 = -0.993134 */
9527                  10031,         /* B2 = 0.306152 */
9528                  -9252,         /* B1 = -0.564728 */
9529                  10031,         /* B0 = 0.306152 */
9530                  30770,         /* A1 = 1.878052 */
9531                  -32563,        /* A2 = -0.993774 */
9532                  22674,         /* B2 = 0.691956 */
9533                  -21465,        /* B1 = -1.31012 */
9534                  22674,         /* B0 = 0.691956 */
9535                  7,             /* Internal filter scaling */
9536                  159,           /* Minimum in-band energy threshold */
9537                  21,            /* 21/32 in-band to broad-band ratio */
9538                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9539         },
9540         {                       /* f445 */
9541                 30709,          /* A1 = -1.874329 */
9542                  -32603,        /* A2 = 0.994965 */
9543                  -83,           /* B2 = -0.002545 */
9544                  0,             /* B1 = 0.000000 */
9545                  83,            /* B0 = 0.002545 */
9546                  30704,         /* A1 = -1.874084 */
9547                  -32692,        /* A2 = 0.997711 */
9548                  10641,         /* B2 = 0.324738 */
9549                  -9947,         /* B1 = -0.607147 */
9550                  10641,         /* B0 = 0.324738 */
9551                  30796,         /* A1 = -1.879639 */
9552                  -32694,        /* A2 = 0.997772 */
9553                  10079,         /* B2 = 0.307587 */
9554                  9513,          /* B1 = 0.580688 */
9555                  10079,         /* B0 = 0.307587 */
9556                  5,             /* Internal filter scaling */
9557                  159,           /* Minimum in-band energy threshold */
9558                  21,            /* 21/32 in-band to broad-band ratio */
9559                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9560         },
9561         {                       /* f450 */
9562                 30664,          /* A1 = -1.871643 */
9563                  -32603,        /* A2 = 0.994965 */
9564                  -164,          /* B2 = -0.005029 */
9565                  0,             /* B1 = 0.000000 */
9566                  164,           /* B0 = 0.005029 */
9567                  30661,         /* A1 = -1.871399 */
9568                  -32692,        /* A2 = 0.997711 */
9569                  15294,         /* B2 = 0.466736 */
9570                  -14275,        /* B1 = -0.871307 */
9571                  15294,         /* B0 = 0.466736 */
9572                  30751,         /* A1 = -1.876953 */
9573                  -32694,        /* A2 = 0.997772 */
9574                  3548,          /* B2 = 0.108284 */
9575                  -3344,         /* B1 = -0.204155 */
9576                  3548,          /* B0 = 0.108284 */
9577                  5,             /* Internal filter scaling */
9578                  159,           /* Minimum in-band energy threshold */
9579                  21,            /* 21/32 in-band to broad-band ratio */
9580                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9581         },
9582         {                       /* f452 */
9583                 30653,          /* A1 = -1.870911 */
9584                  -32615,        /* A2 = 0.995361 */
9585                  -209,          /* B2 = -0.006382 */
9586                  0,             /* B1 = 0.000000 */
9587                  209,           /* B0 = 0.006382 */
9588                  30647,         /* A1 = -1.870605 */
9589                  -32702,        /* A2 = 0.997986 */
9590                  18971,         /* B2 = 0.578979 */
9591                  -17716,        /* B1 = -1.081299 */
9592                  18971,         /* B0 = 0.578979 */
9593                  30738,         /* A1 = -1.876099 */
9594                  -32702,        /* A2 = 0.998016 */
9595                  2967,          /* B2 = 0.090561 */
9596                  -2793,         /* B1 = -0.170502 */
9597                  2967,          /* B0 = 0.090561 */
9598                  5,             /* Internal filter scaling */
9599                  159,           /* Minimum in-band energy threshold */
9600                  21,            /* 21/32 in-band to broad-band ratio */
9601                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9602         },
9603         {                       /* f475 */
9604                 30437,          /* A1 = -1.857727 */
9605                  -32603,        /* A2 = 0.994965 */
9606                  -264,          /* B2 = -0.008062 */
9607                  0,             /* B1 = 0.000000 */
9608                  264,           /* B0 = 0.008062 */
9609                  30430,         /* A1 = -1.857300 */
9610                  -32692,        /* A2 = 0.997711 */
9611                  21681,         /* B2 = 0.661682 */
9612                  -20082,        /* B1 = -1.225708 */
9613                  21681,         /* B0 = 0.661682 */
9614                  30526,         /* A1 = -1.863220 */
9615                  -32694,        /* A2 = 0.997742 */
9616                  1559,          /* B2 = 0.047600 */
9617                  -1459,         /* B1 = -0.089096 */
9618                  1559,          /* B0 = 0.047600 */
9619                  5,             /* Internal filter scaling */
9620                  159,           /* Minimum in-band energy threshold */
9621                  21,            /* 21/32 in-band to broad-band ratio */
9622                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9623         },
9624         {                       /* f480_620[] */
9625                 28975,          /* A1 = 1.768494 */
9626                  -30955,        /* A2 = -0.944672 */
9627                  -1026,         /* B2 = -0.03133 */
9628                  0,             /* B1 = 0 */
9629                  1026,          /* B0 = 0.03133 */
9630                  28613,         /* A1 = 1.746399 */
9631                  -32089,        /* A2 = -0.979309 */
9632                  14214,         /* B2 = 0.433807 */
9633                  -12202,        /* B1 = -0.744812 */
9634                  14214,         /* B0 = 0.433807 */
9635                  30243,         /* A1 = 1.845947 */
9636                  -32238,        /* A2 = -0.983856 */
9637                  24825,         /* B2 = 0.757629 */
9638                  -23402,        /* B1 = -1.428345 */
9639                  24825,         /* B0 = 0.757629 */
9640                  7,             /* Internal filter scaling */
9641                  159,           /* Minimum in-band energy threshold */
9642                  21,            /* 21/32 in-band to broad-band ratio */
9643                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9644         },
9645         {                       /* f494 */
9646                 30257,          /* A1 = -1.846741 */
9647                  -32605,        /* A2 = 0.995056 */
9648                  -249,          /* B2 = -0.007625 */
9649                  0,             /* B1 = 0.000000 */
9650                  249,           /* B0 = 0.007625 */
9651                  30247,         /* A1 = -1.846191 */
9652                  -32694,        /* A2 = 0.997772 */
9653                  18088,         /* B2 = 0.552002 */
9654                  -16652,        /* B1 = -1.016418 */
9655                  18088,         /* B0 = 0.552002 */
9656                  30348,         /* A1 = -1.852295 */
9657                  -32696,        /* A2 = 0.997803 */
9658                  2099,          /* B2 = 0.064064 */
9659                  -1953,         /* B1 = -0.119202 */
9660                  2099,          /* B0 = 0.064064 */
9661                  5,             /* Internal filter scaling */
9662                  159,           /* Minimum in-band energy threshold */
9663                  21,            /* 21/32 in-band to broad-band ratio */
9664                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9665         },
9666         {                       /* f500 */
9667                 30202,          /* A1 = -1.843431 */
9668                  -32624,        /* A2 = 0.995622 */
9669                  -413,          /* B2 = -0.012622 */
9670                  0,             /* B1 = 0.000000 */
9671                  413,           /* B0 = 0.012622 */
9672                  30191,         /* A1 = -1.842721 */
9673                  -32714,        /* A2 = 0.998364 */
9674                  25954,         /* B2 = 0.792057 */
9675                  -23890,        /* B1 = -1.458131 */
9676                  25954,         /* B0 = 0.792057 */
9677                  30296,         /* A1 = -1.849172 */
9678                  -32715,        /* A2 = 0.998397 */
9679                  2007,          /* B2 = 0.061264 */
9680                  -1860,         /* B1 = -0.113568 */
9681                  2007,          /* B0 = 0.061264 */
9682                  5,             /* Internal filter scaling */
9683                  159,           /* Minimum in-band energy threshold */
9684                  21,            /* 21/32 in-band to broad-band ratio */
9685                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9686         },
9687         {                       /* f520 */
9688                 30001,          /* A1 = -1.831116 */
9689                  -32613,        /* A2 = 0.995270 */
9690                  -155,          /* B2 = -0.004750 */
9691                  0,             /* B1 = 0.000000 */
9692                  155,           /* B0 = 0.004750 */
9693                  29985,         /* A1 = -1.830200 */
9694                  -32710,        /* A2 = 0.998260 */
9695                  6584,          /* B2 = 0.200928 */
9696                  -6018,         /* B1 = -0.367355 */
9697                  6584,          /* B0 = 0.200928 */
9698                  30105,         /* A1 = -1.837524 */
9699                  -32712,        /* A2 = 0.998291 */
9700                  23812,         /* B2 = 0.726685 */
9701                  -21936,        /* B1 = -1.338928 */
9702                  23812,         /* B0 = 0.726685 */
9703                  5,             /* Internal filter scaling */
9704                  159,           /* Minimum in-band energy threshold */
9705                  21,            /* 21/32 in-band to broad-band ratio */
9706                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9707         },
9708         {                       /* f523 */
9709                 29964,          /* A1 = -1.828918 */
9710                  -32601,        /* A2 = 0.994904 */
9711                  -101,          /* B2 = -0.003110 */
9712                  0,             /* B1 = 0.000000 */
9713                  101,           /* B0 = 0.003110 */
9714                  29949,         /* A1 = -1.827942 */
9715                  -32700,        /* A2 = 0.997925 */
9716                  11041,         /* B2 = 0.336975 */
9717                  -10075,        /* B1 = -0.614960 */
9718                  11041,         /* B0 = 0.336975 */
9719                  30070,         /* A1 = -1.835388 */
9720                  -32702,        /* A2 = 0.997986 */
9721                  16762,         /* B2 = 0.511536 */
9722                  -15437,        /* B1 = -0.942230 */
9723                  16762,         /* B0 = 0.511536 */
9724                  5,             /* Internal filter scaling */
9725                  159,           /* Minimum in-band energy threshold */
9726                  21,            /* 21/32 in-band to broad-band ratio */
9727                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9728         },
9729         {                       /* f525 */
9730                 29936,          /* A1 = -1.827209 */
9731                  -32584,        /* A2 = 0.994415 */
9732                  -91,           /* B2 = -0.002806 */
9733                  0,             /* B1 = 0.000000 */
9734                  91,            /* B0 = 0.002806 */
9735                  29921,         /* A1 = -1.826233 */
9736                  -32688,        /* A2 = 0.997559 */
9737                  11449,         /* B2 = 0.349396 */
9738                  -10426,        /* B1 = -0.636383 */
9739                  11449,         /* B0 = 0.349396 */
9740                  30045,         /* A1 = -1.833862 */
9741                  -32688,        /* A2 = 0.997589 */
9742                  13055,         /* B2 = 0.398407 */
9743                  -12028,        /* B1 = -0.734161 */
9744                  13055,         /* B0 = 0.398407 */
9745                  5,             /* Internal filter scaling */
9746                  159,           /* Minimum in-band energy threshold */
9747                  21,            /* 21/32 in-band to broad-band ratio */
9748                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9749         },
9750         {                       /* f540_660[] */
9751                 28499,          /* A1 = 1.739441 */
9752                  -31129,        /* A2 = -0.949982 */
9753                  -849,          /* B2 = -0.025922 */
9754                  0,             /* B1 = 0 */
9755                  849,           /* B0 = 0.025922 */
9756                  28128,         /* A1 = 1.716797 */
9757                  -32130,        /* A2 = -0.98056 */
9758                  14556,         /* B2 = 0.444214 */
9759                  -12251,        /* B1 = -0.747772 */
9760                  14556,         /* B0 = 0.444244 */
9761                  29667,         /* A1 = 1.81073 */
9762                  -32244,        /* A2 = -0.984039 */
9763                  23038,         /* B2 = 0.703064 */
9764                  -21358,        /* B1 = -1.303589 */
9765                  23040,         /* B0 = 0.703125 */
9766                  7,             /* Internal filter scaling */
9767                  159,           /* Minimum in-band energy threshold */
9768                  21,            /* 21/32 in-band to broad-band ratio */
9769                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9770         },
9771         {                       /* f587 */
9772                 29271,          /* A1 = -1.786560 */
9773                  -32599,        /* A2 = 0.994873 */
9774                  -490,          /* B2 = -0.014957 */
9775                  0,             /* B1 = 0.000000 */
9776                  490,           /* B0 = 0.014957 */
9777                  29246,         /* A1 = -1.785095 */
9778                  -32700,        /* A2 = 0.997925 */
9779                  28961,         /* B2 = 0.883850 */
9780                  -25796,        /* B1 = -1.574463 */
9781                  28961,         /* B0 = 0.883850 */
9782                  29383,         /* A1 = -1.793396 */
9783                  -32700,        /* A2 = 0.997955 */
9784                  1299,          /* B2 = 0.039650 */
9785                  -1169,         /* B1 = -0.071396 */
9786                  1299,          /* B0 = 0.039650 */
9787                  5,             /* Internal filter scaling */
9788                  159,           /* Minimum in-band energy threshold */
9789                  21,            /* 21/32 in-band to broad-band ratio */
9790                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9791         },
9792         {                       /* f590 */
9793                 29230,          /* A1 = -1.784058 */
9794                  -32584,        /* A2 = 0.994415 */
9795                  -418,          /* B2 = -0.012757 */
9796                  0,             /* B1 = 0.000000 */
9797                  418,           /* B0 = 0.012757 */
9798                  29206,         /* A1 = -1.782593 */
9799                  -32688,        /* A2 = 0.997559 */
9800                  36556,         /* B2 = 1.115601 */
9801                  -32478,        /* B1 = -1.982300 */
9802                  36556,         /* B0 = 1.115601 */
9803                  29345,         /* A1 = -1.791077 */
9804                  -32688,        /* A2 = 0.997589 */
9805                  897,           /* B2 = 0.027397 */
9806                  -808,          /* B1 = -0.049334 */
9807                  897,           /* B0 = 0.027397 */
9808                  5,             /* Internal filter scaling */
9809                  159,           /* Minimum in-band energy threshold */
9810                  21,            /* 21/32 in-band to broad-band ratio */
9811                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9812         },
9813         {                       /* f600 */
9814                 29116,          /* A1 = -1.777100 */
9815                  -32603,        /* A2 = 0.994965 */
9816                  -165,          /* B2 = -0.005039 */
9817                  0,             /* B1 = 0.000000 */
9818                  165,           /* B0 = 0.005039 */
9819                  29089,         /* A1 = -1.775452 */
9820                  -32708,        /* A2 = 0.998199 */
9821                  6963,          /* B2 = 0.212494 */
9822                  -6172,         /* B1 = -0.376770 */
9823                  6963,          /* B0 = 0.212494 */
9824                  29237,         /* A1 = -1.784485 */
9825                  -32710,        /* A2 = 0.998230 */
9826                  24197,         /* B2 = 0.738464 */
9827                  -21657,        /* B1 = -1.321899 */
9828                  24197,         /* B0 = 0.738464 */
9829                  5,             /* Internal filter scaling */
9830                  159,           /* Minimum in-band energy threshold */
9831                  21,            /* 21/32 in-band to broad-band ratio */
9832                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9833         },
9834         {                       /* f660 */
9835                 28376,          /* A1 = -1.731934 */
9836                  -32567,        /* A2 = 0.993896 */
9837                  -363,          /* B2 = -0.011102 */
9838                  0,             /* B1 = 0.000000 */
9839                  363,           /* B0 = 0.011102 */
9840                  28337,         /* A1 = -1.729614 */
9841                  -32683,        /* A2 = 0.997434 */
9842                  21766,         /* B2 = 0.664246 */
9843                  -18761,        /* B1 = -1.145081 */
9844                  21766,         /* B0 = 0.664246 */
9845                  28513,         /* A1 = -1.740356 */
9846                  -32686,        /* A2 = 0.997498 */
9847                  2509,          /* B2 = 0.076584 */
9848                  -2196,         /* B1 = -0.134041 */
9849                  2509,          /* B0 = 0.076584 */
9850                  5,             /* Internal filter scaling */
9851                  159,           /* Minimum in-band energy threshold */
9852                  21,            /* 21/32 in-band to broad-band ratio */
9853                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9854         },
9855         {                       /* f700 */
9856                 27844,          /* A1 = -1.699463 */
9857                  -32563,        /* A2 = 0.993744 */
9858                  -366,          /* B2 = -0.011187 */
9859                  0,             /* B1 = 0.000000 */
9860                  366,           /* B0 = 0.011187 */
9861                  27797,         /* A1 = -1.696655 */
9862                  -32686,        /* A2 = 0.997498 */
9863                  22748,         /* B2 = 0.694214 */
9864                  -19235,        /* B1 = -1.174072 */
9865                  22748,         /* B0 = 0.694214 */
9866                  27995,         /* A1 = -1.708740 */
9867                  -32688,        /* A2 = 0.997559 */
9868                  2964,          /* B2 = 0.090477 */
9869                  -2546,         /* B1 = -0.155449 */
9870                  2964,          /* B0 = 0.090477 */
9871                  5,             /* Internal filter scaling */
9872                  159,           /* Minimum in-band energy threshold */
9873                  21,            /* 21/32 in-band to broad-band ratio */
9874                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9875         },
9876         {                       /* f740 */
9877                 27297,          /* A1 = -1.666077 */
9878                  -32551,        /* A2 = 0.993408 */
9879                  -345,          /* B2 = -0.010540 */
9880                  0,             /* B1 = 0.000000 */
9881                  345,           /* B0 = 0.010540 */
9882                  27240,         /* A1 = -1.662598 */
9883                  -32683,        /* A2 = 0.997406 */
9884                  22560,         /* B2 = 0.688477 */
9885                  -18688,        /* B1 = -1.140625 */
9886                  22560,         /* B0 = 0.688477 */
9887                  27461,         /* A1 = -1.676147 */
9888                  -32684,        /* A2 = 0.997467 */
9889                  3541,          /* B2 = 0.108086 */
9890                  -2985,         /* B1 = -0.182220 */
9891                  3541,          /* B0 = 0.108086 */
9892                  5,             /* Internal filter scaling */
9893                  159,           /* Minimum in-band energy threshold */
9894                  21,            /* 21/32 in-band to broad-band ratio */
9895                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9896         },
9897         {                       /* f750 */
9898                 27155,          /* A1 = -1.657410 */
9899                  -32551,        /* A2 = 0.993408 */
9900                  -462,          /* B2 = -0.014117 */
9901                  0,             /* B1 = 0.000000 */
9902                  462,           /* B0 = 0.014117 */
9903                  27097,         /* A1 = -1.653870 */
9904                  -32683,        /* A2 = 0.997406 */
9905                  32495,         /* B2 = 0.991699 */
9906                  -26776,        /* B1 = -1.634338 */
9907                  32495,         /* B0 = 0.991699 */
9908                  27321,         /* A1 = -1.667542 */
9909                  -32684,        /* A2 = 0.997467 */
9910                  1835,          /* B2 = 0.056007 */
9911                  -1539,         /* B1 = -0.093948 */
9912                  1835,          /* B0 = 0.056007 */
9913                  5,             /* Internal filter scaling */
9914                  159,           /* Minimum in-band energy threshold */
9915                  21,            /* 21/32 in-band to broad-band ratio */
9916                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9917         },
9918         {                       /* f750_1450[] */
9919                 19298,          /* A1 = 1.177917 */
9920                  -24471,        /* A2 = -0.746796 */
9921                  -4152,         /* B2 = -0.126709 */
9922                  0,             /* B1 = 0 */
9923                  4152,          /* B0 = 0.126709 */
9924                  12902,         /* A1 = 0.787476 */
9925                  -29091,        /* A2 = -0.887817 */
9926                  12491,         /* B2 = 0.38121 */
9927                  -1794,         /* B1 = -0.109528 */
9928                  12494,         /* B0 = 0.381317 */
9929                  26291,         /* A1 = 1.604736 */
9930                  -30470,        /* A2 = -0.929901 */
9931                  28859,         /* B2 = 0.880737 */
9932                  -26084,        /* B1 = -1.592102 */
9933                  28861,         /* B0 = 0.880798 */
9934                  7,             /* Internal filter scaling */
9935                  159,           /* Minimum in-band energy threshold */
9936                  21,            /* 21/32 in-band to broad-band ratio */
9937                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9938         },
9939         {                       /* f770 */
9940                 26867,          /* A1 = -1.639832 */
9941                  -32551,        /* A2 = 0.993408 */
9942                  -123,          /* B2 = -0.003755 */
9943                  0,             /* B1 = 0.000000 */
9944                  123,           /* B0 = 0.003755 */
9945                  26805,         /* A1 = -1.636108 */
9946                  -32683,        /* A2 = 0.997406 */
9947                  17297,         /* B2 = 0.527863 */
9948                  -14096,        /* B1 = -0.860382 */
9949                  17297,         /* B0 = 0.527863 */
9950                  27034,         /* A1 = -1.650085 */
9951                  -32684,        /* A2 = 0.997467 */
9952                  12958,         /* B2 = 0.395477 */
9953                  -10756,        /* B1 = -0.656525 */
9954                  12958,         /* B0 = 0.395477 */
9955                  5,             /* Internal filter scaling */
9956                  159,           /* Minimum in-band energy threshold */
9957                  21,            /* 21/32 in-band to broad-band ratio */
9958                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9959         },
9960         {                       /* f800 */
9961                 26413,          /* A1 = -1.612122 */
9962                  -32547,        /* A2 = 0.993286 */
9963                  -223,          /* B2 = -0.006825 */
9964                  0,             /* B1 = 0.000000 */
9965                  223,           /* B0 = 0.006825 */
9966                  26342,         /* A1 = -1.607849 */
9967                  -32686,        /* A2 = 0.997498 */
9968                  6391,          /* B2 = 0.195053 */
9969                  -5120,         /* B1 = -0.312531 */
9970                  6391,          /* B0 = 0.195053 */
9971                  26593,         /* A1 = -1.623108 */
9972                  -32688,        /* A2 = 0.997559 */
9973                  23681,         /* B2 = 0.722717 */
9974                  -19328,        /* B1 = -1.179688 */
9975                  23681,         /* B0 = 0.722717 */
9976                  5,             /* Internal filter scaling */
9977                  159,           /* Minimum in-band energy threshold */
9978                  21,            /* 21/32 in-band to broad-band ratio */
9979                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9980         },
9981         {                       /* f816 */
9982                 26168,          /* A1 = -1.597209 */
9983                  -32528,        /* A2 = 0.992706 */
9984                  -235,          /* B2 = -0.007182 */
9985                  0,             /* B1 = 0.000000 */
9986                  235,           /* B0 = 0.007182 */
9987                  26092,         /* A1 = -1.592590 */
9988                  -32675,        /* A2 = 0.997192 */
9989                  20823,         /* B2 = 0.635498 */
9990                  -16510,        /* B1 = -1.007751 */
9991                  20823,         /* B0 = 0.635498 */
9992                  26363,         /* A1 = -1.609070 */
9993                  -32677,        /* A2 = 0.997253 */
9994                  6739,          /* B2 = 0.205688 */
9995                  -5459,         /* B1 = -0.333206 */
9996                  6739,          /* B0 = 0.205688 */
9997                  5,             /* Internal filter scaling */
9998                  159,           /* Minimum in-band energy threshold */
9999                  21,            /* 21/32 in-band to broad-band ratio */
10000                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10001         },
10002         {                       /* f850 */
10003                 25641,          /* A1 = -1.565063 */
10004                  -32536,        /* A2 = 0.992950 */
10005                  -121,          /* B2 = -0.003707 */
10006                  0,             /* B1 = 0.000000 */
10007                  121,           /* B0 = 0.003707 */
10008                  25560,         /* A1 = -1.560059 */
10009                  -32684,        /* A2 = 0.997437 */
10010                  18341,         /* B2 = 0.559753 */
10011                  -14252,        /* B1 = -0.869904 */
10012                  18341,         /* B0 = 0.559753 */
10013                  25837,         /* A1 = -1.577026 */
10014                  -32684,        /* A2 = 0.997467 */
10015                  16679,         /* B2 = 0.509003 */
10016                  -13232,        /* B1 = -0.807648 */
10017                  16679,         /* B0 = 0.509003 */
10018                  5,             /* Internal filter scaling */
10019                  159,           /* Minimum in-band energy threshold */
10020                  21,            /* 21/32 in-band to broad-band ratio */
10021                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10022         },
10023         {                       /* f857_1645[] */
10024                 16415,          /* A1 = 1.001953 */
10025                  -23669,        /* A2 = -0.722321 */
10026                  -4549,         /* B2 = -0.138847 */
10027                  0,             /* B1 = 0 */
10028                  4549,          /* B0 = 0.138847 */
10029                  8456,          /* A1 = 0.516174 */
10030                  -28996,        /* A2 = -0.884918 */
10031                  13753,         /* B2 = 0.419724 */
10032                  -12,           /* B1 = -0.000763 */
10033                  13757,         /* B0 = 0.419846 */
10034                  24632,         /* A1 = 1.503418 */
10035                  -30271,        /* A2 = -0.923828 */
10036                  29070,         /* B2 = 0.887146 */
10037                  -25265,        /* B1 = -1.542114 */
10038                  29073,         /* B0 = 0.887268 */
10039                  7,             /* Internal filter scaling */
10040                  159,           /* Minimum in-band energy threshold */
10041                  21,            /* 21/32 in-band to broad-band ratio */
10042                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10043         },
10044         {                       /* f900 */
10045                 24806,          /* A1 = -1.514099 */
10046                  -32501,        /* A2 = 0.991852 */
10047                  -326,          /* B2 = -0.009969 */
10048                  0,             /* B1 = 0.000000 */
10049                  326,           /* B0 = 0.009969 */
10050                  24709,         /* A1 = -1.508118 */
10051                  -32659,        /* A2 = 0.996674 */
10052                  20277,         /* B2 = 0.618835 */
10053                  -15182,        /* B1 = -0.926636 */
10054                  20277,         /* B0 = 0.618835 */
10055                  25022,         /* A1 = -1.527222 */
10056                  -32661,        /* A2 = 0.996735 */
10057                  4320,          /* B2 = 0.131836 */
10058                  -3331,         /* B1 = -0.203339 */
10059                  4320,          /* B0 = 0.131836 */
10060                  5,             /* Internal filter scaling */
10061                  159,           /* Minimum in-band energy threshold */
10062                  21,            /* 21/32 in-band to broad-band ratio */
10063                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10064         },
10065         {                       /* f900_1300[] */
10066                 19776,          /* A1 = 1.207092 */
10067                  -27437,        /* A2 = -0.837341 */
10068                  -2666,         /* B2 = -0.081371 */
10069                  0,             /* B1 = 0 */
10070                  2666,          /* B0 = 0.081371 */
10071                  16302,         /* A1 = 0.995026 */
10072                  -30354,        /* A2 = -0.926361 */
10073                  10389,         /* B2 = 0.317062 */
10074                  -3327,         /* B1 = -0.203064 */
10075                  10389,         /* B0 = 0.317062 */
10076                  24299,         /* A1 = 1.483154 */
10077                  -30930,        /* A2 = -0.943909 */
10078                  25016,         /* B2 = 0.763428 */
10079                  -21171,        /* B1 = -1.292236 */
10080                  25016,         /* B0 = 0.763428 */
10081                  7,             /* Internal filter scaling */
10082                  159,           /* Minimum in-band energy threshold */
10083                  21,            /* 21/32 in-band to broad-band ratio */
10084                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10085         },
10086         {                       /* f935_1215[] */
10087                 20554,          /* A1 = 1.254517 */
10088                  -28764,        /* A2 = -0.877838 */
10089                  -2048,         /* B2 = -0.062515 */
10090                  0,             /* B1 = 0 */
10091                  2048,          /* B0 = 0.062515 */
10092                  18209,         /* A1 = 1.11145 */
10093                  -30951,        /* A2 = -0.94458 */
10094                  9390,          /* B2 = 0.286575 */
10095                  -3955,         /* B1 = -0.241455 */
10096                  9390,          /* B0 = 0.286575 */
10097                  23902,         /* A1 = 1.458923 */
10098                  -31286,        /* A2 = -0.954803 */
10099                  23252,         /* B2 = 0.709595 */
10100                  -19132,        /* B1 = -1.167725 */
10101                  23252,         /* B0 = 0.709595 */
10102                  7,             /* Internal filter scaling */
10103                  159,           /* Minimum in-band energy threshold */
10104                  21,            /* 21/32 in-band to broad-band ratio */
10105                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10106         },
10107         {                       /* f941_1477[] */
10108                 17543,          /* A1 = 1.07074 */
10109                  -26220,        /* A2 = -0.800201 */
10110                  -3298,         /* B2 = -0.100647 */
10111                  0,             /* B1 = 0 */
10112                  3298,          /* B0 = 0.100647 */
10113                  12423,         /* A1 = 0.75827 */
10114                  -30036,        /* A2 = -0.916626 */
10115                  12651,         /* B2 = 0.386078 */
10116                  -2444,         /* B1 = -0.14917 */
10117                  12653,         /* B0 = 0.386154 */
10118                  23518,         /* A1 = 1.435425 */
10119                  -30745,        /* A2 = -0.938293 */
10120                  27282,         /* B2 = 0.832581 */
10121                  -22529,        /* B1 = -1.375122 */
10122                  27286,         /* B0 = 0.832703 */
10123                  7,             /* Internal filter scaling */
10124                  159,           /* Minimum in-band energy threshold */
10125                  21,            /* 21/32 in-band to broad-band ratio */
10126                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10127         },
10128         {                       /* f942 */
10129                 24104,          /* A1 = -1.471252 */
10130                  -32507,        /* A2 = 0.992065 */
10131                  -351,          /* B2 = -0.010722 */
10132                  0,             /* B1 = 0.000000 */
10133                  351,           /* B0 = 0.010722 */
10134                  23996,         /* A1 = -1.464600 */
10135                  -32671,        /* A2 = 0.997040 */
10136                  22848,         /* B2 = 0.697266 */
10137                  -16639,        /* B1 = -1.015564 */
10138                  22848,         /* B0 = 0.697266 */
10139                  24332,         /* A1 = -1.485168 */
10140                  -32673,        /* A2 = 0.997101 */
10141                  4906,          /* B2 = 0.149727 */
10142                  -3672,         /* B1 = -0.224174 */
10143                  4906,          /* B0 = 0.149727 */
10144                  5,             /* Internal filter scaling */
10145                  159,           /* Minimum in-band energy threshold */
10146                  21,            /* 21/32 in-band to broad-band ratio */
10147                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10148         },
10149         {                       /* f950 */
10150                 23967,          /* A1 = -1.462830 */
10151                  -32507,        /* A2 = 0.992065 */
10152                  -518,          /* B2 = -0.015821 */
10153                  0,             /* B1 = 0.000000 */
10154                  518,           /* B0 = 0.015821 */
10155                  23856,         /* A1 = -1.456055 */
10156                  -32671,        /* A2 = 0.997040 */
10157                  26287,         /* B2 = 0.802246 */
10158                  -19031,        /* B1 = -1.161560 */
10159                  26287,         /* B0 = 0.802246 */
10160                  24195,         /* A1 = -1.476746 */
10161                  -32673,        /* A2 = 0.997101 */
10162                  2890,          /* B2 = 0.088196 */
10163                  -2151,         /* B1 = -0.131317 */
10164                  2890,          /* B0 = 0.088196 */
10165                  5,             /* Internal filter scaling */
10166                  159,           /* Minimum in-band energy threshold */
10167                  21,            /* 21/32 in-band to broad-band ratio */
10168                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10169         },
10170         {                       /* f950_1400[] */
10171                 18294,          /* A1 = 1.116638 */
10172                  -26962,        /* A2 = -0.822845 */
10173                  -2914,         /* B2 = -0.088936 */
10174                  0,             /* B1 = 0 */
10175                  2914,          /* B0 = 0.088936 */
10176                  14119,         /* A1 = 0.861786 */
10177                  -30227,        /* A2 = -0.922455 */
10178                  11466,         /* B2 = 0.349945 */
10179                  -2833,         /* B1 = -0.172943 */
10180                  11466,         /* B0 = 0.349945 */
10181                  23431,         /* A1 = 1.430115 */
10182                  -30828,        /* A2 = -0.940796 */
10183                  25331,         /* B2 = 0.773071 */
10184                  -20911,        /* B1 = -1.276367 */
10185                  25331,         /* B0 = 0.773071 */
10186                  7,             /* Internal filter scaling */
10187                  159,           /* Minimum in-band energy threshold */
10188                  21,            /* 21/32 in-band to broad-band ratio */
10189                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10190         },
10191         {                       /* f975 */
10192                 23521,          /* A1 = -1.435608 */
10193                  -32489,        /* A2 = 0.991516 */
10194                  -193,          /* B2 = -0.005915 */
10195                  0,             /* B1 = 0.000000 */
10196                  193,           /* B0 = 0.005915 */
10197                  23404,         /* A1 = -1.428467 */
10198                  -32655,        /* A2 = 0.996582 */
10199                  17740,         /* B2 = 0.541412 */
10200                  -12567,        /* B1 = -0.767029 */
10201                  17740,         /* B0 = 0.541412 */
10202                  23753,         /* A1 = -1.449829 */
10203                  -32657,        /* A2 = 0.996613 */
10204                  9090,          /* B2 = 0.277405 */
10205                  -6662,         /* B1 = -0.406647 */
10206                  9090,          /* B0 = 0.277405 */
10207                  5,             /* Internal filter scaling */
10208                  159,           /* Minimum in-band energy threshold */
10209                  21,            /* 21/32 in-band to broad-band ratio */
10210                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10211         },
10212         {                       /* f1000 */
10213                 23071,          /* A1 = -1.408203 */
10214                  -32489,        /* A2 = 0.991516 */
10215                  -293,          /* B2 = -0.008965 */
10216                  0,             /* B1 = 0.000000 */
10217                  293,           /* B0 = 0.008965 */
10218                  22951,         /* A1 = -1.400818 */
10219                  -32655,        /* A2 = 0.996582 */
10220                  5689,          /* B2 = 0.173645 */
10221                  -3951,         /* B1 = -0.241150 */
10222                  5689,          /* B0 = 0.173645 */
10223                  23307,         /* A1 = -1.422607 */
10224                  -32657,        /* A2 = 0.996613 */
10225                  18692,         /* B2 = 0.570435 */
10226                  -13447,        /* B1 = -0.820770 */
10227                  18692,         /* B0 = 0.570435 */
10228                  5,             /* Internal filter scaling */
10229                  159,           /* Minimum in-band energy threshold */
10230                  21,            /* 21/32 in-band to broad-band ratio */
10231                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10232         },
10233         {                       /* f1020 */
10234                 22701,          /* A1 = -1.385620 */
10235                  -32474,        /* A2 = 0.991058 */
10236                  -292,          /* B2 = -0.008933 */
10237                  0,             /*163840      , B1 = 10.000000 */
10238                  292,           /* B0 = 0.008933 */
10239                  22564,         /* A1 = -1.377258 */
10240                  -32655,        /* A2 = 0.996552 */
10241                  20756,         /* B2 = 0.633423 */
10242                  -14176,        /* B1 = -0.865295 */
10243                  20756,         /* B0 = 0.633423 */
10244                  22960,         /* A1 = -1.401428 */
10245                  -32657,        /* A2 = 0.996613 */
10246                  6520,          /* B2 = 0.198990 */
10247                  -4619,         /* B1 = -0.281937 */
10248                  6520,          /* B0 = 0.198990 */
10249                  5,             /* Internal filter scaling */
10250                  159,           /* Minimum in-band energy threshold */
10251                  21,            /* 21/32 in-band to broad-band ratio */
10252                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10253         },
10254         {                       /* f1050 */
10255                 22142,          /* A1 = -1.351501 */
10256                  -32474,        /* A2 = 0.991058 */
10257                  -147,          /* B2 = -0.004493 */
10258                  0,             /* B1 = 0.000000 */
10259                  147,           /* B0 = 0.004493 */
10260                  22000,         /* A1 = -1.342834 */
10261                  -32655,        /* A2 = 0.996552 */
10262                  15379,         /* B2 = 0.469360 */
10263                  -10237,        /* B1 = -0.624847 */
10264                  15379,         /* B0 = 0.469360 */
10265                  22406,         /* A1 = -1.367554 */
10266                  -32657,        /* A2 = 0.996613 */
10267                  17491,         /* B2 = 0.533783 */
10268                  -12096,        /* B1 = -0.738312 */
10269                  17491,         /* B0 = 0.533783 */
10270                  5,             /* Internal filter scaling */
10271                  159,           /* Minimum in-band energy threshold */
10272                  21,            /* 21/32 in-band to broad-band ratio */
10273                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10274         },
10275         {                       /* f1100_1750[] */
10276                 12973,          /* A1 = 0.79184 */
10277                  -24916,        /* A2 = -0.760376 */
10278                  6655,          /* B2 = 0.203102 */
10279                  367,           /* B1 = 0.0224 */
10280                  6657,          /* B0 = 0.203171 */
10281                  5915,          /* A1 = 0.361053 */
10282                  -29560,        /* A2 = -0.90213 */
10283                  -7777,         /* B2 = -0.23735 */
10284                  0,             /* B1 = 0 */
10285                  7777,          /* B0 = 0.23735 */
10286                  20510,         /* A1 = 1.251892 */
10287                  -30260,        /* A2 = -0.923462 */
10288                  26662,         /* B2 = 0.81366 */
10289                  -20573,        /* B1 = -1.255737 */
10290                  26668,         /* B0 = 0.813843 */
10291                  7,             /* Internal filter scaling */
10292                  159,           /* Minimum in-band energy threshold */
10293                  21,            /* 21/32 in-band to broad-band ratio */
10294                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10295         },
10296         {                       /* f1140 */
10297                 20392,          /* A1 = -1.244629 */
10298                  -32460,        /* A2 = 0.990601 */
10299                  -270,          /* B2 = -0.008240 */
10300                  0,             /* B1 = 0.000000 */
10301                  270,           /* B0 = 0.008240 */
10302                  20218,         /* A1 = -1.234009 */
10303                  -32655,        /* A2 = 0.996582 */
10304                  21337,         /* B2 = 0.651154 */
10305                  -13044,        /* B1 = -0.796143 */
10306                  21337,         /* B0 = 0.651154 */
10307                  20684,         /* A1 = -1.262512 */
10308                  -32657,        /* A2 = 0.996643 */
10309                  8572,          /* B2 = 0.261612 */
10310                  -5476,         /* B1 = -0.334244 */
10311                  8572,          /* B0 = 0.261612 */
10312                  5,             /* Internal filter scaling */
10313                  159,           /* Minimum in-band energy threshold */
10314                  21,            /* 21/32 in-band to broad-band ratio */
10315                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10316         },
10317         {                       /* f1200 */
10318                 19159,          /* A1 = -1.169373 */
10319                  -32456,        /* A2 = 0.990509 */
10320                  -335,          /* B2 = -0.010252 */
10321                  0,             /* B1 = 0.000000 */
10322                  335,           /* B0 = 0.010252 */
10323                  18966,         /* A1 = -1.157593 */
10324                  -32661,        /* A2 = 0.996735 */
10325                  6802,          /* B2 = 0.207588 */
10326                  -3900,         /* B1 = -0.238098 */
10327                  6802,          /* B0 = 0.207588 */
10328                  19467,         /* A1 = -1.188232 */
10329                  -32661,        /* A2 = 0.996765 */
10330                  25035,         /* B2 = 0.764008 */
10331                  -15049,        /* B1 = -0.918579 */
10332                  25035,         /* B0 = 0.764008 */
10333                  5,             /* Internal filter scaling */
10334                  159,           /* Minimum in-band energy threshold */
10335                  21,            /* 21/32 in-band to broad-band ratio */
10336                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10337         },
10338         {                       /* f1209 */
10339                 18976,          /* A1 = -1.158264 */
10340                  -32439,        /* A2 = 0.989990 */
10341                  -183,          /* B2 = -0.005588 */
10342                  0,             /* B1 = 0.000000 */
10343                  183,           /* B0 = 0.005588 */
10344                  18774,         /* A1 = -1.145874 */
10345                  -32650,        /* A2 = 0.996429 */
10346                  15468,         /* B2 = 0.472076 */
10347                  -8768,         /* B1 = -0.535217 */
10348                  15468,         /* B0 = 0.472076 */
10349                  19300,         /* A1 = -1.177979 */
10350                  -32652,        /* A2 = 0.996490 */
10351                  19840,         /* B2 = 0.605499 */
10352                  -11842,        /* B1 = -0.722809 */
10353                  19840,         /* B0 = 0.605499 */
10354                  5,             /* Internal filter scaling */
10355                  159,           /* Minimum in-band energy threshold */
10356                  21,            /* 21/32 in-band to broad-band ratio */
10357                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10358         },
10359         {                       /* f1330 */
10360                 16357,          /* A1 = -0.998413 */
10361                  -32368,        /* A2 = 0.987793 */
10362                  -217,          /* B2 = -0.006652 */
10363                  0,             /* B1 = 0.000000 */
10364                  217,           /* B0 = 0.006652 */
10365                  16107,         /* A1 = -0.983126 */
10366                  -32601,        /* A2 = 0.994904 */
10367                  11602,         /* B2 = 0.354065 */
10368                  -5555,         /* B1 = -0.339111 */
10369                  11602,         /* B0 = 0.354065 */
10370                  16722,         /* A1 = -1.020630 */
10371                  -32603,        /* A2 = 0.994965 */
10372                  15574,         /* B2 = 0.475311 */
10373                  -8176,         /* B1 = -0.499069 */
10374                  15574,         /* B0 = 0.475311 */
10375                  5,             /* Internal filter scaling */
10376                  159,           /* Minimum in-band energy threshold */
10377                  21,            /* 21/32 in-band to broad-band ratio */
10378                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10379         },
10380         {                       /* f1336 */
10381                 16234,          /* A1 = -0.990875 */
10382                  32404,         /* A2 = -0.988922 */
10383                  -193,          /* B2 = -0.005908 */
10384                  0,             /* B1 = 0.000000 */
10385                  193,           /* B0 = 0.005908 */
10386                  15986,         /* A1 = -0.975769 */
10387                  -32632,        /* A2 = 0.995880 */
10388                  18051,         /* B2 = 0.550903 */
10389                  -8658,         /* B1 = -0.528473 */
10390                  18051,         /* B0 = 0.550903 */
10391                  16591,         /* A1 = -1.012695 */
10392                  -32634,        /* A2 = 0.995941 */
10393                  15736,         /* B2 = 0.480240 */
10394                  -8125,         /* B1 = -0.495926 */
10395                  15736,         /* B0 = 0.480240 */
10396                  5,             /* Internal filter scaling */
10397                  159,           /* Minimum in-band energy threshold */
10398                  21,            /* 21/32 in-band to broad-band ratio */
10399                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10400         },
10401         {                       /* f1366 */
10402                 15564,          /* A1 = -0.949982 */
10403                  -32404,        /* A2 = 0.988922 */
10404                  -269,          /* B2 = -0.008216 */
10405                  0,             /* B1 = 0.000000 */
10406                  269,           /* B0 = 0.008216 */
10407                  15310,         /* A1 = -0.934479 */
10408                  -32632,        /* A2 = 0.995880 */
10409                  10815,         /* B2 = 0.330063 */
10410                  -4962,         /* B1 = -0.302887 */
10411                  10815,         /* B0 = 0.330063 */
10412                  15924,         /* A1 = -0.971924 */
10413                  -32634,        /* A2 = 0.995941 */
10414                  18880,         /* B2 = 0.576172 */
10415                  -9364,         /* B1 = -0.571594 */
10416                  18880,         /* B0 = 0.576172 */
10417                  5,             /* Internal filter scaling */
10418                  159,           /* Minimum in-band energy threshold */
10419                  21,            /* 21/32 in-band to broad-band ratio */
10420                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10421         },
10422         {                       /* f1380 */
10423                 15247,          /* A1 = -0.930603 */
10424                  -32397,        /* A2 = 0.988708 */
10425                  -244,          /* B2 = -0.007451 */
10426                  0,             /* B1 = 0.000000 */
10427                  244,           /* B0 = 0.007451 */
10428                  14989,         /* A1 = -0.914886 */
10429                  -32627,        /* A2 = 0.995697 */
10430                  18961,         /* B2 = 0.578644 */
10431                  -8498,         /* B1 = -0.518707 */
10432                  18961,         /* B0 = 0.578644 */
10433                  15608,         /* A1 = -0.952667 */
10434                  -32628,        /* A2 = 0.995758 */
10435                  11145,         /* B2 = 0.340134 */
10436                  -5430,         /* B1 = -0.331467 */
10437                  11145,         /* B0 = 0.340134 */
10438                  5,             /* Internal filter scaling */
10439                  159,           /* Minimum in-band energy threshold */
10440                  21,            /* 21/32 in-band to broad-band ratio */
10441                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10442         },
10443         {                       /* f1400 */
10444                 14780,          /* A1 = -0.902130 */
10445                  -32393,        /* A2 = 0.988586 */
10446                  -396,          /* B2 = -0.012086 */
10447                  0,             /* B1 = 0.000000 */
10448                  396,           /* B0 = 0.012086 */
10449                  14510,         /* A1 = -0.885651 */
10450                  -32630,        /* A2 = 0.995819 */
10451                  6326,          /* B2 = 0.193069 */
10452                  -2747,         /* B1 = -0.167671 */
10453                  6326,          /* B0 = 0.193069 */
10454                  15154,         /* A1 = -0.924957 */
10455                  -32632,        /* A2 = 0.995850 */
10456                  23235,         /* B2 = 0.709076 */
10457                  -10983,        /* B1 = -0.670380 */
10458                  23235,         /* B0 = 0.709076 */
10459                  5,             /* Internal filter scaling */
10460                  159,           /* Minimum in-band energy threshold */
10461                  21,            /* 21/32 in-band to broad-band ratio */
10462                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10463         },
10464         {                       /* f1477 */
10465                 13005,          /* A1 = -0.793793 */
10466                  -32368,        /* A2 = 0.987823 */
10467                  -500,          /* B2 = -0.015265 */
10468                  0,             /* B1 = 0.000000 */
10469                  500,           /* B0 = 0.015265 */
10470                  12708,         /* A1 = -0.775665 */
10471                  -32615,        /* A2 = 0.995331 */
10472                  11420,         /* B2 = 0.348526 */
10473                  -4306,         /* B1 = -0.262833 */
10474                  11420,         /* B0 = 0.348526 */
10475                  13397,         /* A1 = -0.817688 */
10476                  -32615,        /* A2 = 0.995361 */
10477                  9454,          /* B2 = 0.288528 */
10478                  -3981,         /* B1 = -0.243027 */
10479                  9454,          /* B0 = 0.288528 */
10480                  5,             /* Internal filter scaling */
10481                  159,           /* Minimum in-band energy threshold */
10482                  21,            /* 21/32 in-band to broad-band ratio */
10483                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10484         },
10485         {                       /* f1600 */
10486                 10046,          /* A1 = -0.613190 */
10487                  -32331,        /* A2 = 0.986694 */
10488                  -455,          /* B2 = -0.013915 */
10489                  0,             /* B1 = 0.000000 */
10490                  455,           /* B0 = 0.013915 */
10491                  9694,          /* A1 = -0.591705 */
10492                  -32601,        /* A2 = 0.994934 */
10493                  6023,          /* B2 = 0.183815 */
10494                  -1708,         /* B1 = -0.104279 */
10495                  6023,          /* B0 = 0.183815 */
10496                  10478,         /* A1 = -0.639587 */
10497                  -32603,        /* A2 = 0.994965 */
10498                  22031,         /* B2 = 0.672333 */
10499                  -7342,         /* B1 = -0.448151 */
10500                  22031,         /* B0 = 0.672333 */
10501                  5,             /* Internal filter scaling */
10502                  159,           /* Minimum in-band energy threshold */
10503                  21,            /* 21/32 in-band to broad-band ratio */
10504                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10505         },
10506         {                       /* f1633_1638[] */
10507                 9181,           /* A1 = 0.560394 */
10508                  -32256,        /* A2 = -0.984375 */
10509                  -556,          /* B2 = -0.016975 */
10510                  0,             /* B1 = 0 */
10511                  556,           /* B0 = 0.016975 */
10512                  8757,          /* A1 = 0.534515 */
10513                  -32574,        /* A2 = -0.99408 */
10514                  8443,          /* B2 = 0.25769 */
10515                  -2135,         /* B1 = -0.130341 */
10516                  8443,          /* B0 = 0.25769 */
10517                  9691,          /* A1 = 0.591522 */
10518                  -32574,        /* A2 = -0.99411 */
10519                  15446,         /* B2 = 0.471375 */
10520                  -4809,         /* B1 = -0.293579 */
10521                  15446,         /* B0 = 0.471375 */
10522                  7,             /* Internal filter scaling */
10523                  159,           /* Minimum in-band energy threshold */
10524                  21,            /* 21/32 in-band to broad-band ratio */
10525                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10526         },
10527         {                       /* f1800 */
10528                 5076,           /* A1 = -0.309875 */
10529                  -32304,        /* A2 = 0.985840 */
10530                  -508,          /* B2 = -0.015503 */
10531                  0,             /* B1 = 0.000000 */
10532                  508,           /* B0 = 0.015503 */
10533                  4646,          /* A1 = -0.283600 */
10534                  -32605,        /* A2 = 0.995026 */
10535                  6742,          /* B2 = 0.205780 */
10536                  -878,          /* B1 = -0.053635 */
10537                  6742,          /* B0 = 0.205780 */
10538                  5552,          /* A1 = -0.338928 */
10539                  -32605,        /* A2 = 0.995056 */
10540                  23667,         /* B2 = 0.722260 */
10541                  -4297,         /* B1 = -0.262329 */
10542                  23667,         /* B0 = 0.722260 */
10543                  5,             /* Internal filter scaling */
10544                  159,           /* Minimum in-band energy threshold */
10545                  21,            /* 21/32 in-band to broad-band ratio */
10546                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10547         },
10548         {                       /* f1860 */
10549                 3569,           /* A1 = -0.217865 */
10550                  -32292,        /* A2 = 0.985504 */
10551                  -239,          /* B2 = -0.007322 */
10552                  0,             /* B1 = 0.000000 */
10553                  239,           /* B0 = 0.007322 */
10554                  3117,          /* A1 = -0.190277 */
10555                  -32603,        /* A2 = 0.994965 */
10556                  18658,         /* B2 = 0.569427 */
10557                  -1557,         /* B1 = -0.095032 */
10558                  18658,         /* B0 = 0.569427 */
10559                  4054,          /* A1 = -0.247437 */
10560                  -32603,        /* A2 = 0.994965 */
10561                  18886,         /* B2 = 0.576385 */
10562                  -2566,         /* B1 = -0.156647 */
10563                  18886,         /* B0 = 0.576385 */
10564                  5,             /* Internal filter scaling */
10565                  159,           /* Minimum in-band energy threshold */
10566                  21,            /* 21/32 in-band to broad-band ratio */
10567                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10568         },
10569 };
10570 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10571 {
10572         unsigned short cmd;
10573         int cnt, max;
10574
10575         if (jf->filter > 3) {
10576                 return -1;
10577         }
10578         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10579
10580                 return -1;
10581         if (!jf->enable) {
10582                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10583
10584                         return -1;
10585                 else
10586                         return 0;
10587         } else {
10588                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10589
10590                         return -1;
10591                 /* Select the filter (f0 - f3) to use. */
10592                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10593                         return -1;
10594         }
10595         if (jf->freq < 12 && jf->freq > 3) {
10596                 /* Select the frequency for the selected filter. */
10597                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10598                         return -1;
10599         } else if (jf->freq > 11) {
10600                 /* We need to load a programmable filter set for undefined */
10601                 /* frequencies.  So we will point the filter to a programmable set. */
10602                 /* Since there are only 4 filters and 4 programmable sets, we will */
10603                 /* just point the filter to the same number set and program it for the */
10604                 /* frequency we want. */
10605                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10606                         return -1;
10607                 if (j->ver.low != 0x12) {
10608                         cmd = 0x515B;
10609                         max = 19;
10610                 } else {
10611                         cmd = 0x515E;
10612                         max = 15;
10613                 }
10614                 if (ixj_WriteDSPCommand(cmd, j))
10615                         return -1;
10616                 for (cnt = 0; cnt < max; cnt++) {
10617                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10618                                 return -1;
10619                 }
10620         }
10621         j->filter_en[jf->filter] = jf->enable;
10622         return 0;
10623 }
10624
10625 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10626 {
10627         unsigned short cmd;
10628         int cnt, max;
10629         if (jfr->filter > 3) {
10630                 return -1;
10631         }
10632         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10633                 return -1;
10634
10635         if (!jfr->enable) {
10636                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10637                         return -1;
10638                 else
10639                         return 0;
10640         } else {
10641                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10642                         return -1;
10643                 /* Select the filter (f0 - f3) to use. */
10644                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10645                         return -1;
10646         }
10647         /* We need to load a programmable filter set for undefined */
10648         /* frequencies.  So we will point the filter to a programmable set. */
10649         /* Since there are only 4 filters and 4 programmable sets, we will */
10650         /* just point the filter to the same number set and program it for the */
10651         /* frequency we want. */
10652         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10653                 return -1;
10654         if (j->ver.low != 0x12) {
10655                 cmd = 0x515B;
10656                 max = 19;
10657         } else {
10658                 cmd = 0x515E;
10659                 max = 15;
10660         }
10661         if (ixj_WriteDSPCommand(cmd, j))
10662                 return -1;
10663         for (cnt = 0; cnt < max; cnt++) {
10664                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10665                         return -1;
10666         }
10667         j->filter_en[jfr->filter] = jfr->enable;
10668         return 0;
10669 }
10670
10671 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10672 {
10673         int freq0, freq1;
10674         unsigned short data;
10675         if (ti->freq0) {
10676                 freq0 = ti->freq0;
10677         } else {
10678                 freq0 = 0x7FFF;
10679         }
10680
10681         if (ti->freq1) {
10682                 freq1 = ti->freq1;
10683         } else {
10684                 freq1 = 0x7FFF;
10685         }
10686
10687         if(ti->tone_index > 12 && ti->tone_index < 28)
10688         {
10689                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10690                         return -1;
10691                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10692                         return -1;
10693                 data = freq0;
10694                 if (ixj_WriteDSPCommand(data, j))
10695                         return -1;
10696                 data = freq1;
10697                 if (ixj_WriteDSPCommand(data, j))
10698                         return -1;
10699         }
10700         return freq0;
10701 }
10702