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 * cp);
 465 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE * 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 *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 *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 *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 *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 * cp)
5942 {
5943         IXJ_CADENCE *lcp;
5944         IXJ_CADENCE_ELEMENT *lcep;
5945         IXJ_TONE ti;
5946
5947         lcp = kmalloc(sizeof(IXJ_CADENCE), GFP_KERNEL);
5948         if (lcp == NULL)
5949                 return -ENOMEM;
5950         if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_CADENCE)) || (unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT) )
5951         {
5952                 kfree(lcp);
5953                 return -EFAULT;
5954         }
5955         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5956         if (lcep == NULL) {
5957                 kfree(lcp);
5958                 return -ENOMEM;
5959         }
5960         if (copy_from_user(lcep, lcp->ce, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5961         {
5962                 kfree(lcep);
5963                 kfree(lcp);
5964                 return -EFAULT;
5965         }
5966         if (j->cadence_t) {
5967                 kfree(j->cadence_t->ce);
5968                 kfree(j->cadence_t);
5969         }
5970         lcp->ce = (void *) lcep;
5971         j->cadence_t = lcp;
5972         j->tone_cadence_state = 0;
5973         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5974         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5975         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5976                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5977                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5978                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5979                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5980                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5981                 ixj_init_tone(j, &ti);
5982         }
5983         ixj_play_tone(j, lcp->ce[0].index);
5984         return 1;
5985 }
5986
5987 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE * cp)
5988 {
5989         IXJ_FILTER_CADENCE *lcp;
5990         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5991         if (lcp == NULL) {
5992                 if(ixjdebug & 0x0001) {
5993                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5994                 }
5995                 return -ENOMEM;
5996         }
5997         if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_FILTER_CADENCE))) {
5998                 if(ixjdebug & 0x0001) {
5999                         printk(KERN_INFO "Could not copy cadence to kernel\n");
6000                 }
6001                 kfree(lcp);
6002                 return -EFAULT;
6003         }
6004         if (lcp->filter > 5) {
6005                 if(ixjdebug & 0x0001) {
6006                         printk(KERN_INFO "Cadence out of range\n");
6007                 }
6008                 kfree(lcp);
6009                 return -1;
6010         }
6011         j->cadence_f[lcp->filter].state = 0;
6012         j->cadence_f[lcp->filter].enable = lcp->enable;
6013         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
6014         j->cadence_f[lcp->filter].on1 = lcp->on1;
6015         j->cadence_f[lcp->filter].on1min = 0;
6016         j->cadence_f[lcp->filter].on1max = 0;
6017         j->cadence_f[lcp->filter].off1 = lcp->off1;
6018         j->cadence_f[lcp->filter].off1min = 0;
6019         j->cadence_f[lcp->filter].off1max = 0;
6020         j->cadence_f[lcp->filter].on2 = lcp->on2;
6021         j->cadence_f[lcp->filter].on2min = 0;
6022         j->cadence_f[lcp->filter].on2max = 0;
6023         j->cadence_f[lcp->filter].off2 = lcp->off2;
6024         j->cadence_f[lcp->filter].off2min = 0;
6025         j->cadence_f[lcp->filter].off2max = 0;
6026         j->cadence_f[lcp->filter].on3 = lcp->on3;
6027         j->cadence_f[lcp->filter].on3min = 0;
6028         j->cadence_f[lcp->filter].on3max = 0;
6029         j->cadence_f[lcp->filter].off3 = lcp->off3;
6030         j->cadence_f[lcp->filter].off3min = 0;
6031         j->cadence_f[lcp->filter].off3max = 0;
6032         kfree(lcp);
6033         if(ixjdebug & 0x0002) {
6034                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
6035         }
6036         return 0;
6037 }
6038
6039 static void add_caps(IXJ *j)
6040 {
6041         j->caps = 0;
6042         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
6043         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
6044         j->caplist[j->caps].captype = vendor;
6045         j->caplist[j->caps].handle = j->caps++;
6046         j->caplist[j->caps].captype = device;
6047         switch (j->cardtype) {
6048         case QTI_PHONEJACK:
6049                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
6050                 break;
6051         case QTI_LINEJACK:
6052                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
6053                 break;
6054         case QTI_PHONEJACK_LITE:
6055                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
6056                 break;
6057         case QTI_PHONEJACK_PCI:
6058                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
6059                 break;
6060         case QTI_PHONECARD:
6061                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
6062                 break;
6063         }
6064         j->caplist[j->caps].cap = j->cardtype;
6065         j->caplist[j->caps].handle = j->caps++;
6066         strcpy(j->caplist[j->caps].desc, "POTS");
6067         j->caplist[j->caps].captype = port;
6068         j->caplist[j->caps].cap = pots;
6069         j->caplist[j->caps].handle = j->caps++;
6070
6071         /* add devices that can do speaker/mic */
6072         switch (j->cardtype) {
6073         case QTI_PHONEJACK:
6074         case QTI_LINEJACK:
6075         case QTI_PHONEJACK_PCI:
6076         case QTI_PHONECARD:
6077                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
6078                 j->caplist[j->caps].captype = port;
6079                 j->caplist[j->caps].cap = speaker;
6080                 j->caplist[j->caps].handle = j->caps++;
6081         default:
6082                 break;
6083         }
6084
6085         /* add devices that can do handset */
6086         switch (j->cardtype) {
6087         case QTI_PHONEJACK:
6088                 strcpy(j->caplist[j->caps].desc, "HANDSET");
6089                 j->caplist[j->caps].captype = port;
6090                 j->caplist[j->caps].cap = handset;
6091                 j->caplist[j->caps].handle = j->caps++;
6092                 break;
6093         default:
6094                 break;
6095         }
6096
6097         /* add devices that can do PSTN */
6098         switch (j->cardtype) {
6099         case QTI_LINEJACK:
6100                 strcpy(j->caplist[j->caps].desc, "PSTN");
6101                 j->caplist[j->caps].captype = port;
6102                 j->caplist[j->caps].cap = pstn;
6103                 j->caplist[j->caps].handle = j->caps++;
6104                 break;
6105         default:
6106                 break;
6107         }
6108
6109         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6110         strcpy(j->caplist[j->caps].desc, "ULAW");
6111         j->caplist[j->caps].captype = codec;
6112         j->caplist[j->caps].cap = ULAW;
6113         j->caplist[j->caps].handle = j->caps++;
6114
6115         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6116         j->caplist[j->caps].captype = codec;
6117         j->caplist[j->caps].cap = LINEAR16;
6118         j->caplist[j->caps].handle = j->caps++;
6119
6120         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6121         j->caplist[j->caps].captype = codec;
6122         j->caplist[j->caps].cap = LINEAR8;
6123         j->caplist[j->caps].handle = j->caps++;
6124
6125         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6126         j->caplist[j->caps].captype = codec;
6127         j->caplist[j->caps].cap = WSS;
6128         j->caplist[j->caps].handle = j->caps++;
6129
6130         /* software ALAW codec, made from ULAW */
6131         strcpy(j->caplist[j->caps].desc, "ALAW");
6132         j->caplist[j->caps].captype = codec;
6133         j->caplist[j->caps].cap = ALAW;
6134         j->caplist[j->caps].handle = j->caps++;
6135
6136         /* version 12 of the 8020 does the following codecs in a broken way */
6137         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6138                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6139                 j->caplist[j->caps].captype = codec;
6140                 j->caplist[j->caps].cap = G723_63;
6141                 j->caplist[j->caps].handle = j->caps++;
6142
6143                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6144                 j->caplist[j->caps].captype = codec;
6145                 j->caplist[j->caps].cap = G723_53;
6146                 j->caplist[j->caps].handle = j->caps++;
6147
6148                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6149                 j->caplist[j->caps].captype = codec;
6150                 j->caplist[j->caps].cap = TS48;
6151                 j->caplist[j->caps].handle = j->caps++;
6152
6153                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6154                 j->caplist[j->caps].captype = codec;
6155                 j->caplist[j->caps].cap = TS41;
6156                 j->caplist[j->caps].handle = j->caps++;
6157         }
6158
6159         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6160         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6161                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6162                 j->caplist[j->caps].captype = codec;
6163                 j->caplist[j->caps].cap = TS85;
6164                 j->caplist[j->caps].handle = j->caps++;
6165         }
6166
6167         /* 8021 chips can do G728 */
6168         if (j->dsp.low == 0x21) {
6169                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6170                 j->caplist[j->caps].captype = codec;
6171                 j->caplist[j->caps].cap = G728;
6172                 j->caplist[j->caps].handle = j->caps++;
6173         }
6174
6175         /* 8021/8022 chips can do G729 if loaded */
6176         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6177                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6178                 j->caplist[j->caps].captype = codec;
6179                 j->caplist[j->caps].cap = G729;
6180                 j->caplist[j->caps].handle = j->caps++;
6181         }
6182         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6183                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6184                 j->caplist[j->caps].captype = codec;
6185                 j->caplist[j->caps].cap = G729B;
6186                 j->caplist[j->caps].handle = j->caps++;
6187         }
6188 }
6189
6190 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6191 {
6192         int cnt;
6193         int retval = 0;
6194         for (cnt = 0; cnt < j->caps; cnt++) {
6195                 if (pcreq->captype == j->caplist[cnt].captype
6196                     && pcreq->cap == j->caplist[cnt].cap) {
6197                         retval = 1;
6198                         break;
6199                 }
6200         }
6201         return retval;
6202 }
6203
6204 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6205 {
6206         IXJ_TONE ti;
6207         IXJ_FILTER jf;
6208         IXJ_FILTER_RAW jfr;
6209
6210         unsigned int raise, mant;
6211         unsigned int minor = iminor(inode);
6212         int board = NUM(inode);
6213
6214         IXJ *j = get_ixj(NUM(inode));
6215
6216         int retval = 0;
6217
6218         /*
6219          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6220          *    This is necessary to keep the DSP from locking up.
6221          */
6222         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6223                 set_current_state(TASK_INTERRUPTIBLE);
6224                 schedule_timeout(1);
6225         }
6226         if (ixjdebug & 0x0040)
6227                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6228         if (minor >= IXJMAX) {
6229                 clear_bit(board, &j->busyflags);
6230                 return -ENODEV;
6231         }
6232         /*
6233          *    Check ioctls only root can use.
6234          */
6235         if (!capable(CAP_SYS_ADMIN)) {
6236                 switch (cmd) {
6237                 case IXJCTL_TESTRAM:
6238                 case IXJCTL_HZ:
6239                         retval = -EPERM;
6240                 }
6241         }
6242         switch (cmd) {
6243         case IXJCTL_TESTRAM:
6244                 ixj_testram(j);
6245                 retval = (j->ssr.high << 8) + j->ssr.low;
6246                 break;
6247         case IXJCTL_CARDTYPE:
6248                 retval = j->cardtype;
6249                 break;
6250         case IXJCTL_SERIAL:
6251                 retval = j->serial;
6252                 break;
6253         case IXJCTL_VERSION:
6254                 if (copy_to_user((char *) arg, ixj_c_revision, strlen(ixj_c_revision)))
6255                         retval = -EFAULT;
6256                 break;
6257         case PHONE_RING_CADENCE:
6258                 j->ring_cadence = arg;
6259                 break;
6260         case IXJCTL_CIDCW:
6261                 if(arg) {
6262                         if (copy_from_user(&j->cid_send, (char *)arg, sizeof(PHONE_CID))) {
6263                                 retval = -EFAULT;
6264                                 break;
6265                         }
6266                 } else {
6267                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6268                 }
6269                 ixj_write_cidcw(j);
6270                 break;
6271         /* Binary compatbility */
6272         case OLD_PHONE_RING_START:
6273                 arg = 0;
6274                 /* Fall through */
6275         case PHONE_RING_START:
6276                 if(arg) {
6277                         if (copy_from_user(&j->cid_send, (char *)arg, sizeof(PHONE_CID))) {
6278                                 retval = -EFAULT;
6279                                 break;
6280                         }
6281                         ixj_write_cid(j);
6282                 } else {
6283                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6284                 }
6285                 ixj_ring_start(j);
6286                 break;
6287         case PHONE_RING_STOP:
6288                 j->flags.cringing = 0;
6289                 if(j->cadence_f[5].enable) {
6290                         j->cadence_f[5].state = 0;
6291                 }
6292                 ixj_ring_off(j);
6293                 break;
6294         case PHONE_RING:
6295                 retval = ixj_ring(j);
6296                 break;
6297         case PHONE_EXCEPTION:
6298                 retval = j->ex.bytes;
6299                 if(j->ex.bits.flash) {
6300                         j->flash_end = 0;
6301                         j->ex.bits.flash = 0;
6302                 }
6303                 j->ex.bits.pstn_ring = 0;
6304                 j->ex.bits.caller_id = 0;
6305                 j->ex.bits.pstn_wink = 0;
6306                 j->ex.bits.f0 = 0;
6307                 j->ex.bits.f1 = 0;
6308                 j->ex.bits.f2 = 0;
6309                 j->ex.bits.f3 = 0;
6310                 j->ex.bits.fc0 = 0;
6311                 j->ex.bits.fc1 = 0;
6312                 j->ex.bits.fc2 = 0;
6313                 j->ex.bits.fc3 = 0;
6314                 j->ex.bits.reserved = 0;
6315                 break;
6316         case PHONE_HOOKSTATE:
6317                 j->ex.bits.hookstate = 0;
6318                 retval = j->hookstate;  //j->r_hook;
6319                 break;
6320         case IXJCTL_SET_LED:
6321                 LED_SetState(arg, j);
6322                 break;
6323         case PHONE_FRAME:
6324                 retval = set_base_frame(j, arg);
6325                 break;
6326         case PHONE_REC_CODEC:
6327                 retval = set_rec_codec(j, arg);
6328                 break;
6329         case PHONE_VAD:
6330                 ixj_vad(j, arg);
6331                 break;
6332         case PHONE_REC_START:
6333                 ixj_record_start(j);
6334                 break;
6335         case PHONE_REC_STOP:
6336                 ixj_record_stop(j);
6337                 break;
6338         case PHONE_REC_DEPTH:
6339                 set_rec_depth(j, arg);
6340                 break;
6341         case PHONE_REC_VOLUME:
6342                 if(arg == -1) {
6343                         retval = get_rec_volume(j);
6344                 }
6345                 else {
6346                         set_rec_volume(j, arg);
6347                         retval = arg;
6348                 }
6349                 break;
6350         case PHONE_REC_VOLUME_LINEAR:
6351                 if(arg == -1) {
6352                         retval = get_rec_volume_linear(j);
6353                 }
6354                 else {
6355                         set_rec_volume_linear(j, arg);
6356                         retval = arg;
6357                 }
6358                 break;
6359         case IXJCTL_DTMF_PRESCALE:
6360                 if(arg == -1) {
6361                         retval = get_dtmf_prescale(j);
6362                 }
6363                 else {
6364                         set_dtmf_prescale(j, arg);
6365                         retval = arg;
6366                 }
6367                 break;
6368         case PHONE_REC_LEVEL:
6369                 retval = get_rec_level(j);
6370                 break;
6371         case IXJCTL_SC_RXG:
6372                 retval = ixj_siadc(j, arg);
6373                 break;
6374         case IXJCTL_SC_TXG:
6375                 retval = ixj_sidac(j, arg);
6376                 break;
6377         case IXJCTL_AEC_START:
6378                 ixj_aec_start(j, arg);
6379                 break;
6380         case IXJCTL_AEC_STOP:
6381                 aec_stop(j);
6382                 break;
6383         case IXJCTL_AEC_GET_LEVEL:
6384                 retval = j->aec_level;
6385                 break;
6386         case PHONE_PLAY_CODEC:
6387                 retval = set_play_codec(j, arg);
6388                 break;
6389         case PHONE_PLAY_START:
6390                 retval = ixj_play_start(j);
6391                 break;
6392         case PHONE_PLAY_STOP:
6393                 ixj_play_stop(j);
6394                 break;
6395         case PHONE_PLAY_DEPTH:
6396                 set_play_depth(j, arg);
6397                 break;
6398         case PHONE_PLAY_VOLUME:
6399                 if(arg == -1) {
6400                         retval = get_play_volume(j);
6401                 }
6402                 else {
6403                         set_play_volume(j, arg);
6404                         retval = arg;
6405                 }
6406                 break;
6407         case PHONE_PLAY_VOLUME_LINEAR:
6408                 if(arg == -1) {
6409                         retval = get_play_volume_linear(j);
6410                 }
6411                 else {
6412                         set_play_volume_linear(j, arg);
6413                         retval = arg;
6414                 }
6415                 break;
6416         case PHONE_PLAY_LEVEL:
6417                 retval = get_play_level(j);
6418                 break;
6419         case IXJCTL_DSP_TYPE:
6420                 retval = (j->dsp.high << 8) + j->dsp.low;
6421                 break;
6422         case IXJCTL_DSP_VERSION:
6423                 retval = (j->ver.high << 8) + j->ver.low;
6424                 break;
6425         case IXJCTL_HZ:
6426                 hertz = arg;
6427                 break;
6428         case IXJCTL_RATE:
6429                 if (arg > hertz)
6430                         retval = -1;
6431                 else
6432                         samplerate = arg;
6433                 break;
6434         case IXJCTL_DRYBUFFER_READ:
6435                 put_user(j->drybuffer, (unsigned long *) arg);
6436                 break;
6437         case IXJCTL_DRYBUFFER_CLEAR:
6438                 j->drybuffer = 0;
6439                 break;
6440         case IXJCTL_FRAMES_READ:
6441                 put_user(j->framesread, (unsigned long *) arg);
6442                 break;
6443         case IXJCTL_FRAMES_WRITTEN:
6444                 put_user(j->frameswritten, (unsigned long *) arg);
6445                 break;
6446         case IXJCTL_READ_WAIT:
6447                 put_user(j->read_wait, (unsigned long *) arg);
6448                 break;
6449         case IXJCTL_WRITE_WAIT:
6450                 put_user(j->write_wait, (unsigned long *) arg);
6451                 break;
6452         case PHONE_MAXRINGS:
6453                 j->maxrings = arg;
6454                 break;
6455         case PHONE_SET_TONE_ON_TIME:
6456                 ixj_set_tone_on(arg, j);
6457                 break;
6458         case PHONE_SET_TONE_OFF_TIME:
6459                 ixj_set_tone_off(arg, j);
6460                 break;
6461         case PHONE_GET_TONE_ON_TIME:
6462                 if (ixj_get_tone_on(j)) {
6463                         retval = -1;
6464                 } else {
6465                         retval = (j->ssr.high << 8) + j->ssr.low;
6466                 }
6467                 break;
6468         case PHONE_GET_TONE_OFF_TIME:
6469                 if (ixj_get_tone_off(j)) {
6470                         retval = -1;
6471                 } else {
6472                         retval = (j->ssr.high << 8) + j->ssr.low;
6473                 }
6474                 break;
6475         case PHONE_PLAY_TONE:
6476                 if (!j->tone_state)
6477                         retval = ixj_play_tone(j, arg);
6478                 else
6479                         retval = -1;
6480                 break;
6481         case PHONE_GET_TONE_STATE:
6482                 retval = j->tone_state;
6483                 break;
6484         case PHONE_DTMF_READY:
6485                 retval = j->ex.bits.dtmf_ready;
6486                 break;
6487         case PHONE_GET_DTMF:
6488                 if (ixj_hookstate(j)) {
6489                         if (j->dtmf_rp != j->dtmf_wp) {
6490                                 retval = j->dtmfbuffer[j->dtmf_rp];
6491                                 j->dtmf_rp++;
6492                                 if (j->dtmf_rp == 79)
6493                                         j->dtmf_rp = 0;
6494                                 if (j->dtmf_rp == j->dtmf_wp) {
6495                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6496                                 }
6497                         }
6498                 }
6499                 break;
6500         case PHONE_GET_DTMF_ASCII:
6501                 if (ixj_hookstate(j)) {
6502                         if (j->dtmf_rp != j->dtmf_wp) {
6503                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6504                                 case 10:
6505                                         retval = 42;    /* '*'; */
6506
6507                                         break;
6508                                 case 11:
6509                                         retval = 48;    /*'0'; */
6510
6511                                         break;
6512                                 case 12:
6513                                         retval = 35;    /*'#'; */
6514
6515                                         break;
6516                                 case 28:
6517                                         retval = 65;    /*'A'; */
6518
6519                                         break;
6520                                 case 29:
6521                                         retval = 66;    /*'B'; */
6522
6523                                         break;
6524                                 case 30:
6525                                         retval = 67;    /*'C'; */
6526
6527                                         break;
6528                                 case 31:
6529                                         retval = 68;    /*'D'; */
6530
6531                                         break;
6532                                 default:
6533                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6534                                         break;
6535                                 }
6536                                 j->dtmf_rp++;
6537                                 if (j->dtmf_rp == 79)
6538                                         j->dtmf_rp = 0;
6539                                 if(j->dtmf_rp == j->dtmf_wp)
6540                                 {
6541                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6542                                 }
6543                         }
6544                 }
6545                 break;
6546         case PHONE_DTMF_OOB:
6547                 j->flags.dtmf_oob = arg;
6548                 break;
6549         case PHONE_DIALTONE:
6550                 ixj_dialtone(j);
6551                 break;
6552         case PHONE_BUSY:
6553                 ixj_busytone(j);
6554                 break;
6555         case PHONE_RINGBACK:
6556                 ixj_ringback(j);
6557                 break;
6558         case PHONE_WINK:
6559                 if(j->cardtype == QTI_PHONEJACK)
6560                         retval = -1;
6561                 else
6562                         retval = ixj_wink(j);
6563                 break;
6564         case PHONE_CPT_STOP:
6565                 ixj_cpt_stop(j);
6566                 break;
6567         case PHONE_QUERY_CODEC:
6568         {
6569                 struct phone_codec_data pd;
6570                 int val;
6571                 int proto_size[] = {
6572                         -1,
6573                         12, 10, 16, 9, 8, 48, 5,
6574                         40, 40, 80, 40, 40, 6
6575                 };
6576                 if(copy_from_user(&pd, (void *)arg, sizeof(pd))) {
6577                         retval = -EFAULT;
6578                         break;
6579                 }
6580                 if(pd.type<1 || pd.type>13) {
6581                         retval = -EPROTONOSUPPORT;
6582                         break;
6583                 }
6584                 if(pd.type<G729)
6585                         val=proto_size[pd.type];
6586                 else switch(j->baseframe.low)
6587                 {
6588                         case 0xA0:val=2*proto_size[pd.type];break;
6589                         case 0x50:val=proto_size[pd.type];break;
6590                         default:val=proto_size[pd.type]*3;break;
6591                 }
6592                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6593                 if(copy_to_user((void *)arg, &pd, sizeof(pd)))
6594                         retval = -EFAULT;
6595                 break;
6596         }
6597         case IXJCTL_DSP_IDLE:
6598                 idle(j);
6599                 break;
6600         case IXJCTL_MIXER:
6601                 if ((arg & 0xff) == 0xff)
6602                         retval = ixj_get_mixer(arg, j);
6603                 else
6604                         ixj_mixer(arg, j);
6605                 break;
6606         case IXJCTL_DAA_COEFF_SET:
6607                 switch (arg) {
6608                 case DAA_US:
6609                         DAA_Coeff_US(j);
6610                         retval = ixj_daa_write(j);
6611                         break;
6612                 case DAA_UK:
6613                         DAA_Coeff_UK(j);
6614                         retval = ixj_daa_write(j);
6615                         break;
6616                 case DAA_FRANCE:
6617                         DAA_Coeff_France(j);
6618                         retval = ixj_daa_write(j);
6619                         break;
6620                 case DAA_GERMANY:
6621                         DAA_Coeff_Germany(j);
6622                         retval = ixj_daa_write(j);
6623                         break;
6624                 case DAA_AUSTRALIA:
6625                         DAA_Coeff_Australia(j);
6626                         retval = ixj_daa_write(j);
6627                         break;
6628                 case DAA_JAPAN:
6629                         DAA_Coeff_Japan(j);
6630                         retval = ixj_daa_write(j);
6631                         break;
6632                 default:
6633                         retval = 1;
6634                         break;
6635                 }
6636                 break;
6637         case IXJCTL_DAA_AGAIN:
6638                 ixj_daa_cr4(j, arg | 0x02);
6639                 break;
6640         case IXJCTL_PSTN_LINETEST:
6641                 retval = ixj_linetest(j);
6642                 break;
6643         case IXJCTL_VMWI:
6644                 ixj_write_vmwi(j, arg);
6645                 break;
6646         case IXJCTL_CID:
6647                 if (copy_to_user((char *) arg, &j->cid, sizeof(PHONE_CID)))
6648                         retval = -EFAULT;
6649                 j->ex.bits.caller_id = 0;
6650                 break;
6651         case IXJCTL_WINK_DURATION:
6652                 j->winktime = arg;
6653                 break;
6654         case IXJCTL_PORT:
6655                 if (arg)
6656                         retval = ixj_set_port(j, arg);
6657                 else
6658                         retval = j->port;
6659                 break;
6660         case IXJCTL_POTS_PSTN:
6661                 retval = ixj_set_pots(j, arg);
6662                 break;
6663         case PHONE_CAPABILITIES:
6664                 add_caps(j);
6665                 retval = j->caps;
6666                 break;
6667         case PHONE_CAPABILITIES_LIST:
6668                 add_caps(j);
6669                 if (copy_to_user((char *) arg, j->caplist, sizeof(struct phone_capability) * j->caps))
6670                         retval = -EFAULT;
6671                 break;
6672         case PHONE_CAPABILITIES_CHECK:
6673                 {
6674                         struct phone_capability cap;
6675                         if (copy_from_user(&cap, (char *) arg, sizeof(cap)))
6676                                 retval = -EFAULT;
6677                         else {
6678                                 add_caps(j);
6679                                 retval = capabilities_check(j, &cap);
6680                         }
6681                 }
6682                 break;
6683         case PHONE_PSTN_SET_STATE:
6684                 daa_set_mode(j, arg);
6685                 break;
6686         case PHONE_PSTN_GET_STATE:
6687                 retval = j->daa_mode;
6688                 j->ex.bits.pstn_ring = 0;
6689                 break;
6690         case IXJCTL_SET_FILTER:
6691                 if (copy_from_user(&jf, (char *) arg, sizeof(jf)))
6692                         retval = -EFAULT;
6693                 retval = ixj_init_filter(j, &jf);
6694                 break;
6695         case IXJCTL_SET_FILTER_RAW:
6696                 if (copy_from_user(&jfr, (char *) arg, sizeof(jfr)))
6697                         retval = -EFAULT;
6698                 else
6699                         retval = ixj_init_filter_raw(j, &jfr);
6700                 break;
6701         case IXJCTL_GET_FILTER_HIST:
6702                 if(arg<0||arg>3)
6703                         retval = -EINVAL;
6704                 else
6705                         retval = j->filter_hist[arg];
6706                 break;
6707         case IXJCTL_INIT_TONE:
6708                 if (copy_from_user(&ti, (char *) arg, sizeof(ti)))
6709                         retval = -EFAULT;
6710                 else
6711                         retval = ixj_init_tone(j, &ti);
6712                 break;
6713         case IXJCTL_TONE_CADENCE:
6714                 retval = ixj_build_cadence(j, (IXJ_CADENCE *) arg);
6715                 break;
6716         case IXJCTL_FILTER_CADENCE:
6717                 retval = ixj_build_filter_cadence(j, (IXJ_FILTER_CADENCE *) arg);
6718                 break;
6719         case IXJCTL_SIGCTL:
6720                 if (copy_from_user(&j->sigdef, (char *)arg, sizeof(IXJ_SIGDEF))) {
6721                         retval = -EFAULT;
6722                         break;
6723                 }
6724                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6725                 if(j->sigdef.event < 33) {
6726                         raise = 1;
6727                         for(mant = 0; mant < j->sigdef.event; mant++){
6728                                 raise *= 2;
6729                         }
6730                         if(j->sigdef.signal)
6731                                 j->ex_sig.bytes |= raise;
6732                         else
6733                                 j->ex_sig.bytes &= (raise^0xffff);
6734                 }
6735                 break;
6736         case IXJCTL_INTERCOM_STOP:
6737                 if(arg < 0 || arg >= IXJMAX)
6738                         return -EINVAL;
6739                 j->intercom = -1;
6740                 ixj_record_stop(j);
6741                 ixj_play_stop(j);
6742                 idle(j);
6743                 get_ixj(arg)->intercom = -1;
6744                 ixj_record_stop(get_ixj(arg));
6745                 ixj_play_stop(get_ixj(arg));
6746                 idle(get_ixj(arg));
6747                 break;
6748         case IXJCTL_INTERCOM_START:
6749                 if(arg < 0 || arg >= IXJMAX)
6750                         return -EINVAL;
6751                 j->intercom = arg;
6752                 ixj_record_start(j);
6753                 ixj_play_start(j);
6754                 get_ixj(arg)->intercom = board;
6755                 ixj_play_start(get_ixj(arg));
6756                 ixj_record_start(get_ixj(arg));
6757                 break;
6758         }
6759         if (ixjdebug & 0x0040)
6760                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6761         clear_bit(board, &j->busyflags);
6762         return retval;
6763 }
6764
6765 static int ixj_fasync(int fd, struct file *file_p, int mode)
6766 {
6767         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6768
6769         return fasync_helper(fd, file_p, mode, &j->async_queue);
6770 }
6771
6772 struct file_operations ixj_fops =
6773 {
6774         .owner          = THIS_MODULE,
6775         .read           = ixj_enhanced_read,
6776         .write          = ixj_enhanced_write,
6777         .poll           = ixj_poll,
6778         .ioctl          = ixj_ioctl,
6779         .release        = ixj_release,
6780         .fasync         = ixj_fasync
6781 };
6782
6783 static int ixj_linetest(IXJ *j)
6784 {
6785         unsigned long jifwait;
6786
6787         j->flags.pstncheck = 1; /* Testing */
6788         j->flags.pstn_present = 0; /* Assume the line is not there */
6789
6790         daa_int_read(j);        /*Clear DAA Interrupt flags */
6791         /* */
6792         /* Hold all relays in the normally de-energized position. */
6793         /* */
6794
6795         j->pld_slicw.bits.rly1 = 0;
6796         j->pld_slicw.bits.rly2 = 0;
6797         j->pld_slicw.bits.rly3 = 0;
6798         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6799         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6800
6801         outb_p(j->pld_scrw.byte, j->XILINXbase);
6802         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6803         if (j->pld_slicr.bits.potspstn) {
6804                 j->flags.pots_pstn = 1;
6805                 j->flags.pots_correct = 0;
6806                 LED_SetState(0x4, j);
6807         } else {
6808                 j->flags.pots_pstn = 0;
6809                 j->pld_slicw.bits.rly1 = 0;
6810                 j->pld_slicw.bits.rly2 = 0;
6811                 j->pld_slicw.bits.rly3 = 1;
6812                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6813                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6814
6815                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6816                 daa_set_mode(j, SOP_PU_CONVERSATION);
6817                 jifwait = jiffies + hertz;
6818                 while (time_before(jiffies, jifwait)) {
6819                         set_current_state(TASK_INTERRUPTIBLE);
6820                         schedule_timeout(1);
6821                 }
6822                 daa_int_read(j);
6823                 daa_set_mode(j, SOP_PU_RESET);
6824                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6825                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6826                         LED_SetState(0x4, j);
6827                         j->pld_slicw.bits.rly3 = 0;
6828                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6829                 } else {
6830                         j->flags.pots_correct = 1;
6831                         LED_SetState(0x8, j);
6832                         j->pld_slicw.bits.rly1 = 1;
6833                         j->pld_slicw.bits.rly2 = 0;
6834                         j->pld_slicw.bits.rly3 = 0;
6835                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6836                 }
6837         }
6838         j->pld_slicw.bits.rly3 = 0;
6839         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6840         daa_set_mode(j, SOP_PU_CONVERSATION);
6841         jifwait = jiffies + hertz;
6842         while (time_before(jiffies, jifwait)) {
6843                 set_current_state(TASK_INTERRUPTIBLE);
6844                 schedule_timeout(1);
6845         }
6846         daa_int_read(j);
6847         daa_set_mode(j, SOP_PU_RESET);
6848         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6849                 j->pstn_sleeptil = jiffies + (hertz / 4);
6850                 j->flags.pstn_present = 1;
6851         } else {
6852                 j->flags.pstn_present = 0;
6853         }
6854         if (j->flags.pstn_present) {
6855                 if (j->flags.pots_correct) {
6856                         LED_SetState(0xA, j);
6857                 } else {
6858                         LED_SetState(0x6, j);
6859                 }
6860         } else {
6861                 if (j->flags.pots_correct) {
6862                         LED_SetState(0x9, j);
6863                 } else {
6864                         LED_SetState(0x5, j);
6865                 }
6866         }
6867         j->flags.pstncheck = 0; /* Testing */
6868         return j->flags.pstn_present;
6869 }
6870
6871 static int ixj_selfprobe(IXJ *j)
6872 {
6873         unsigned short cmd;
6874         unsigned long jif;
6875         int cnt;
6876         BYTES bytes;
6877
6878         init_waitqueue_head(&j->poll_q);
6879         init_waitqueue_head(&j->read_q);
6880         init_waitqueue_head(&j->write_q);
6881
6882         while(atomic_read(&j->DSPWrite) > 0)
6883                 atomic_dec(&j->DSPWrite);
6884         if (ixjdebug & 0x0002)
6885                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6886         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6887
6888         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6889                 return -1;
6890 /* The read values of the SSR should be 0x00 for the IDLE command */
6891         if (j->ssr.low || j->ssr.high)
6892                 return -1;
6893         if (ixjdebug & 0x0002)
6894                 printk(KERN_INFO "Get Device ID Code\n");
6895         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6896                 return -1;
6897         j->dsp.low = j->ssr.low;
6898         j->dsp.high = j->ssr.high;
6899         if (ixjdebug & 0x0002)
6900                 printk(KERN_INFO "Get Device Version Code\n");
6901         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6902                 return -1;
6903         j->ver.low = j->ssr.low;
6904         j->ver.high = j->ssr.high;
6905         if (!j->cardtype) {
6906                 if (j->dsp.low == 0x21) {
6907                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6908                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6909 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6910                         bytes.low = inb_p(j->XILINXbase + 0x02);
6911                         if (bytes.low == bytes.high)    /*  Register is read only on */
6912                                 /*  Internet PhoneJack Lite */
6913                          {
6914                                 j->cardtype = QTI_PHONEJACK_LITE;
6915                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6916                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6917                                         return -1;
6918                                 }
6919                                 j->pld_slicw.pcib.e1 = 1;
6920                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6921                         } else {
6922                                 j->cardtype = QTI_LINEJACK;
6923
6924                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6925                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6926                                         return -1;
6927                                 }
6928                         }
6929                 } else if (j->dsp.low == 0x22) {
6930                         j->cardtype = QTI_PHONEJACK_PCI;
6931                         request_region(j->XILINXbase, 4, "ixj control");
6932                         j->pld_slicw.pcib.e1 = 1;
6933                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6934                 } else
6935                         j->cardtype = QTI_PHONEJACK;
6936         } else {
6937                 switch (j->cardtype) {
6938                 case QTI_PHONEJACK:
6939                         if (!j->dsp.low != 0x20) {
6940                                 j->dsp.high = 0x80;
6941                                 j->dsp.low = 0x20;
6942                                 ixj_WriteDSPCommand(0x3800, j);
6943                                 j->ver.low = j->ssr.low;
6944                                 j->ver.high = j->ssr.high;
6945                         }
6946                         break;
6947                 case QTI_LINEJACK:
6948                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6949                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6950                                 return -1;
6951                         }
6952                         break;
6953                 case QTI_PHONEJACK_LITE:
6954                 case QTI_PHONEJACK_PCI:
6955                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6956                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6957                                 return -1;
6958                         }
6959                         j->pld_slicw.pcib.e1 = 1;
6960                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6961                         break;
6962                 case QTI_PHONECARD:
6963                         break;
6964                 }
6965         }
6966         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6967                 if (ixjdebug & 0x0002)
6968                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6969                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6970                         return -1;
6971                 if (ixjdebug & 0x0002)
6972                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6973                 if (j->cardtype == QTI_PHONEJACK) {
6974                         cmd = 0x9FF2;
6975                 } else {
6976                         cmd = 0x9FF5;
6977                 }
6978                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6979                         return -1;
6980         } else {
6981                 if (set_base_frame(j, 30) != 30)
6982                         return -1;
6983                 if (ixjdebug & 0x0002)
6984                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6985                 if (j->cardtype == QTI_PHONECARD) {
6986                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6987                                 return -1;
6988                 }
6989                 if (j->cardtype == QTI_LINEJACK) {
6990                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6991                                 return -1;
6992                         if (ixjdebug & 0x0002)
6993                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6994                         j->pld_clock.byte = 0;
6995                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6996                 }
6997         }
6998
6999         if (j->dsp.low == 0x20) {
7000                 if (ixjdebug & 0x0002)
7001                         printk(KERN_INFO "Configure GPIO pins\n");
7002                 j->gpio.bytes.high = 0x09;
7003 /*  bytes.low = 0xEF;  0xF7 */
7004                 j->gpio.bits.gpio1 = 1;
7005                 j->gpio.bits.gpio2 = 1;
7006                 j->gpio.bits.gpio3 = 0;
7007                 j->gpio.bits.gpio4 = 1;
7008                 j->gpio.bits.gpio5 = 1;
7009                 j->gpio.bits.gpio6 = 1;
7010                 j->gpio.bits.gpio7 = 1;
7011                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
7012                 if (ixjdebug & 0x0002)
7013                         printk(KERN_INFO "Enable SLIC\n");
7014                 j->gpio.bytes.high = 0x0B;
7015                 j->gpio.bytes.low = 0x00;
7016                 j->gpio.bits.gpio1 = 0;
7017                 j->gpio.bits.gpio2 = 1;
7018                 j->gpio.bits.gpio5 = 0;
7019                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
7020                 j->port = PORT_POTS;
7021         } else {
7022                 if (j->cardtype == QTI_LINEJACK) {
7023                         LED_SetState(0x1, j);
7024                         jif = jiffies + (hertz / 10);
7025                         while (time_before(jiffies, jif)) {
7026                                 set_current_state(TASK_INTERRUPTIBLE);
7027                                 schedule_timeout(1);
7028                         }
7029                         LED_SetState(0x2, j);
7030                         jif = jiffies + (hertz / 10);
7031                         while (time_before(jiffies, jif)) {
7032                                 set_current_state(TASK_INTERRUPTIBLE);
7033                                 schedule_timeout(1);
7034                         }
7035                         LED_SetState(0x4, j);
7036                         jif = jiffies + (hertz / 10);
7037                         while (time_before(jiffies, jif)) {
7038                                 set_current_state(TASK_INTERRUPTIBLE);
7039                                 schedule_timeout(1);
7040                         }
7041                         LED_SetState(0x8, j);
7042                         jif = jiffies + (hertz / 10);
7043                         while (time_before(jiffies, jif)) {
7044                                 set_current_state(TASK_INTERRUPTIBLE);
7045                                 schedule_timeout(1);
7046                         }
7047                         LED_SetState(0x0, j);
7048                         daa_get_version(j);
7049                         if (ixjdebug & 0x0002)
7050                                 printk("Loading DAA Coefficients\n");
7051                         DAA_Coeff_US(j);
7052                         if (!ixj_daa_write(j)) {
7053                                 printk("DAA write failed on board %d\n", j->board);
7054                                 return -1;
7055                         }
7056                         if(!ixj_daa_cid_reset(j)) {
7057                                 printk("DAA CID reset failed on board %d\n", j->board);
7058                                 return -1;
7059                         }
7060                         j->flags.pots_correct = 0;
7061                         j->flags.pstn_present = 0;
7062                         ixj_linetest(j);
7063                         if (j->flags.pots_correct) {
7064                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7065
7066                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7067                                 j->pld_slicw.bits.rly1 = 1;
7068                                 j->pld_slicw.bits.spken = 1;
7069                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7070                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7071 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7072                                 j->port = PORT_POTS;
7073                         }
7074                         ixj_set_port(j, PORT_PSTN);
7075                         ixj_set_pots(j, 1);
7076                         if (ixjdebug & 0x0002)
7077                                 printk(KERN_INFO "Enable Mixer\n");
7078                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
7079                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
7080
7081                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
7082                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
7083
7084                         ixj_mixer(0x0480, j);   /*FM Left mute */
7085                         ixj_mixer(0x0580, j);   /*FM Right mute */
7086
7087                         ixj_mixer(0x0680, j);   /*CD Left mute */
7088                         ixj_mixer(0x0780, j);   /*CD Right mute */
7089
7090                         ixj_mixer(0x0880, j);   /*Line Left mute */
7091                         ixj_mixer(0x0980, j);   /*Line Right mute */
7092
7093                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
7094                         ixj_mixer(0x0B80, j);   /*Aux right mute */
7095
7096                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
7097                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
7098
7099                         ixj_mixer(0x0E80, j);   /*Mic mute */
7100
7101                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
7102
7103                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
7104                         ixj_mixer(0x110C, j);
7105
7106
7107                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
7108                         ixj_mixer(0x1401, j);
7109
7110                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
7111                         ixj_mixer(0x1501, j);
7112
7113                         ixj_mixer(0x1700, j);   /*Clock select */
7114
7115                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
7116
7117                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
7118
7119                         if (ixjdebug & 0x0002)
7120                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7121                         j->cadence_f[4].state = 0;
7122                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7123                         j->cadence_f[4].off1 = 0;
7124                         j->cadence_f[4].on2 = 0;
7125                         j->cadence_f[4].off2 = 0;
7126                         j->cadence_f[4].on3 = 0;
7127                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7128                         j->pstn_last_rmr = jiffies;
7129
7130                 } else {
7131                         if (j->cardtype == QTI_PHONECARD) {
7132                                 ixj_WriteDSPCommand(0xCF07, j);
7133                                 ixj_WriteDSPCommand(0x00B0, j);
7134                                 ixj_set_port(j, PORT_SPEAKER);
7135                         } else {
7136                                 ixj_set_port(j, PORT_POTS);
7137                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7138 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7139                         }
7140                 }
7141         }
7142
7143         j->intercom = -1;
7144         j->framesread = j->frameswritten = 0;
7145         j->read_wait = j->write_wait = 0;
7146         j->rxreadycheck = j->txreadycheck = 0;
7147
7148         /* initialise the DTMF prescale to a sensible value */
7149         if (j->cardtype == QTI_LINEJACK) {
7150                 set_dtmf_prescale(j, 0x10);
7151         } else {
7152                 set_dtmf_prescale(j, 0x40);
7153         }
7154         set_play_volume(j, 0x100);
7155         set_rec_volume(j, 0x100);
7156
7157         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7158                 return -1;
7159 /* The read values of the SSR should be 0x00 for the IDLE command */
7160         if (j->ssr.low || j->ssr.high)
7161                 return -1;
7162
7163         if (ixjdebug & 0x0002)
7164                 printk(KERN_INFO "Enable Line Monitor\n");
7165
7166         if (ixjdebug & 0x0002)
7167                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7168
7169         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7170                 return -1;
7171
7172         if (ixjdebug & 0x002)
7173                 printk(KERN_INFO "Enable DTMF Detectors\n");
7174
7175         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7176                 return -1;
7177
7178         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7179                 return -1;
7180
7181         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7182
7183         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7184
7185         j->ex.bits.dtmf_ready = 0;
7186         j->dtmf_state = 0;
7187         j->dtmf_wp = j->dtmf_rp = 0;
7188         j->rec_mode = j->play_mode = -1;
7189         j->flags.ringing = 0;
7190         j->maxrings = MAXRINGS;
7191         j->ring_cadence = USA_RING_CADENCE;
7192         j->drybuffer = 0;
7193         j->winktime = 320;
7194         j->flags.dtmf_oob = 0;
7195         for (cnt = 0; cnt < 4; cnt++)
7196                 j->cadence_f[cnt].enable = 0;
7197         /* must be a device on the specified address */
7198         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7199
7200         /* Set up the default signals for events */
7201         for (cnt = 0; cnt < 35; cnt++)
7202                 j->ixj_signals[cnt] = SIGIO;
7203
7204         /* Set the excetion signal enable flags */
7205         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7206         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 =
7207         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;
7208 #ifdef IXJ_DYN_ALLOC
7209         j->fskdata = NULL;
7210 #endif
7211         j->fskdcnt = 0;
7212         j->cidcw_wait = 0;
7213
7214         /* Register with the Telephony for Linux subsystem */
7215         j->p.f_op = &ixj_fops;
7216         j->p.open = ixj_open;
7217         j->p.board = j->board;
7218         phone_register_device(&j->p, PHONE_UNIT_ANY);
7219
7220         ixj_init_timer(j);
7221         ixj_add_timer(j);
7222         return 0;
7223 }
7224
7225 /*
7226  *      Exported service for pcmcia card handling
7227  */
7228
7229 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7230 {
7231         IXJ *j = ixj_alloc();
7232
7233         j->board = 0;
7234
7235         j->DSPbase = dsp;
7236         j->XILINXbase = xilinx;
7237         j->cardtype = QTI_PHONECARD;
7238         ixj_selfprobe(j);
7239         return j;
7240 }
7241
7242 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7243
7244 static int ixj_get_status_proc(char *buf)
7245 {
7246         int len;
7247         int cnt;
7248         IXJ *j;
7249         len = 0;
7250         len += sprintf(buf + len, "%s", ixj_c_rcsid);
7251         len += sprintf(buf + len, "\n%s", ixj_h_rcsid);
7252         len += sprintf(buf + len, "\n%s", ixjuser_h_rcsid);
7253         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7254         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7255         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7256         len += sprintf(buf + len, "\nUsing old telephony API");
7257         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7258
7259         for (cnt = 0; cnt < IXJMAX; cnt++) {
7260                 j = get_ixj(cnt);
7261                 if(j==NULL)
7262                         continue;
7263                 if (j->DSPbase) {
7264                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7265                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7266                         if (j->cardtype != QTI_PHONEJACK)
7267                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7268                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7269                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7270                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7271                         switch (j->cardtype) {
7272                         case (QTI_PHONEJACK):
7273                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7274                                 break;
7275                         case (QTI_LINEJACK):
7276                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7277                                 if (j->flags.g729_loaded)
7278                                         len += sprintf(buf + len, " w/G.729 A/B");
7279                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7280                                 break;
7281                         case (QTI_PHONEJACK_LITE):
7282                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7283                                 if (j->flags.g729_loaded)
7284                                         len += sprintf(buf + len, " w/G.729 A/B");
7285                                 break;
7286                         case (QTI_PHONEJACK_PCI):
7287                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7288                                 if (j->flags.g729_loaded)
7289                                         len += sprintf(buf + len, " w/G.729 A/B");
7290                                 break;
7291                         case (QTI_PHONECARD):
7292                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7293                                 if (j->flags.g729_loaded)
7294                                         len += sprintf(buf + len, " w/G.729 A/B");
7295                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7296                                 if (!j->pccr1.bits.drf)
7297                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7298                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7299                                 break;
7300                         default:
7301                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7302                                 break;
7303                         }
7304                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7305                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7306                         add_caps(j);
7307                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7308                         if (j->dsp.low != 0x20)
7309                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7310                         if (j->flags.cidsent)
7311                                 len += sprintf(buf + len, "\nCaller ID data sent");
7312                         else
7313                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7314
7315                         len += sprintf(buf + len, "\nPlay CODEC ");
7316                         switch (j->play_codec) {
7317                         case G723_63:
7318                                 len += sprintf(buf + len, "G.723.1 6.3");
7319                                 break;
7320                         case G723_53:
7321                                 len += sprintf(buf + len, "G.723.1 5.3");
7322                                 break;
7323                         case TS85:
7324                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7325                                 break;
7326                         case TS48:
7327                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7328                                 break;
7329                         case TS41:
7330                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7331                                 break;
7332                         case G728:
7333                                 len += sprintf(buf + len, "G.728");
7334                                 break;
7335                         case G729:
7336                                 len += sprintf(buf + len, "G.729");
7337                                 break;
7338                         case G729B:
7339                                 len += sprintf(buf + len, "G.729B");
7340                                 break;
7341                         case ULAW:
7342                                 len += sprintf(buf + len, "uLaw");
7343                                 break;
7344                         case ALAW:
7345                                 len += sprintf(buf + len, "aLaw");
7346                                 break;
7347                         case LINEAR16:
7348                                 len += sprintf(buf + len, "16 bit Linear");
7349                                 break;
7350                         case LINEAR8:
7351                                 len += sprintf(buf + len, "8 bit Linear");
7352                                 break;
7353                         case WSS:
7354                                 len += sprintf(buf + len, "Windows Sound System");
7355                                 break;
7356                         default:
7357                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7358                                 break;
7359                         }
7360                         len += sprintf(buf + len, "\nRecord CODEC ");
7361                         switch (j->rec_codec) {
7362                         case G723_63:
7363                                 len += sprintf(buf + len, "G.723.1 6.3");
7364                                 break;
7365                         case G723_53:
7366                                 len += sprintf(buf + len, "G.723.1 5.3");
7367                                 break;
7368                         case TS85:
7369                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7370                                 break;
7371                         case TS48:
7372                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7373                                 break;
7374                         case TS41:
7375                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7376                                 break;
7377                         case G728:
7378                                 len += sprintf(buf + len, "G.728");
7379                                 break;
7380                         case G729:
7381                                 len += sprintf(buf + len, "G.729");
7382                                 break;
7383                         case G729B:
7384                                 len += sprintf(buf + len, "G.729B");
7385                                 break;
7386                         case ULAW:
7387                                 len += sprintf(buf + len, "uLaw");
7388                                 break;
7389                         case ALAW:
7390                                 len += sprintf(buf + len, "aLaw");
7391                                 break;
7392                         case LINEAR16:
7393                                 len += sprintf(buf + len, "16 bit Linear");
7394                                 break;
7395                         case LINEAR8:
7396                                 len += sprintf(buf + len, "8 bit Linear");
7397                                 break;
7398                         case WSS:
7399                                 len += sprintf(buf + len, "Windows Sound System");
7400                                 break;
7401                         default:
7402                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7403                                 break;
7404                         }
7405                         len += sprintf(buf + len, "\nAEC ");
7406                         switch (j->aec_level) {
7407                         case AEC_OFF:
7408                                 len += sprintf(buf + len, "Off");
7409                                 break;
7410                         case AEC_LOW:
7411                                 len += sprintf(buf + len, "Low");
7412                                 break;
7413                         case AEC_MED:
7414                                 len += sprintf(buf + len, "Med");
7415                                 break;
7416                         case AEC_HIGH:
7417                                 len += sprintf(buf + len, "High");
7418                                 break;
7419                         case AEC_AUTO:
7420                                 len += sprintf(buf + len, "Auto");
7421                                 break;
7422                         case AEC_AGC:
7423                                 len += sprintf(buf + len, "AEC/AGC");
7424                                 break;
7425                         default:
7426                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7427                                 break;
7428                         }
7429
7430                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7431                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7432                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7433
7434                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7435
7436                         if (j->cardtype == QTI_LINEJACK) {
7437                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7438                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7439                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7440                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7441                                 switch (j->daa_mode) {
7442                                 case SOP_PU_SLEEP:
7443                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7444                                         break;
7445                                 case SOP_PU_RINGING:
7446                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7447                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7448                                         break;
7449                                 case SOP_PU_CONVERSATION:
7450                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7451                                         break;
7452                                 case SOP_PU_PULSEDIALING:
7453                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7454                                         break;
7455                                 }
7456                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7457                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7458                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7459                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7460                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7461                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7462                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7463                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7464                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7465                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7466                         }
7467                         switch (j->port) {
7468                         case PORT_POTS:
7469                                 len += sprintf(buf + len, "\nPort POTS");
7470                                 break;
7471                         case PORT_PSTN:
7472                                 len += sprintf(buf + len, "\nPort PSTN");
7473                                 break;
7474                         case PORT_SPEAKER:
7475                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7476                                 break;
7477                         case PORT_HANDSET:
7478                                 len += sprintf(buf + len, "\nPort HANDSET");
7479                                 break;
7480                         }
7481                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7482                                 len += sprintf(buf + len, "\nSLIC state ");
7483                                 switch (SLIC_GetState(j)) {
7484                                 case PLD_SLIC_STATE_OC:
7485                                         len += sprintf(buf + len, "OC");
7486                                         break;
7487                                 case PLD_SLIC_STATE_RINGING:
7488                                         len += sprintf(buf + len, "RINGING");
7489                                         break;
7490                                 case PLD_SLIC_STATE_ACTIVE:
7491                                         len += sprintf(buf + len, "ACTIVE");
7492                                         break;
7493                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7494                                         len += sprintf(buf + len, "OHT");
7495                                         break;
7496                                 case PLD_SLIC_STATE_TIPOPEN:
7497                                         len += sprintf(buf + len, "TIPOPEN");
7498                                         break;
7499                                 case PLD_SLIC_STATE_STANDBY:
7500                                         len += sprintf(buf + len, "STANDBY");
7501                                         break;
7502                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7503                                         len += sprintf(buf + len, "APR");
7504                                         break;
7505                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7506                                         len += sprintf(buf + len, "OHTPR");
7507                                         break;
7508                                 default:
7509                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7510                                         break;
7511                                 }
7512                         }
7513                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7514                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7515 #ifdef PERFMON_STATS
7516                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7517                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7518                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7519                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7520                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7521                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7522                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7523                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7524                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7525                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7526                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7527                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7528                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7529                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7530
7531 #endif
7532                         len += sprintf(buf + len, "\n");
7533                 }
7534         }
7535         return len;
7536 }
7537
7538 static int ixj_read_proc(char *page, char **start, off_t off,
7539                               int count, int *eof, void *data)
7540 {
7541         int len = ixj_get_status_proc(page);
7542         if (len <= off+count) *eof = 1;
7543         *start = page + off;
7544         len -= off;
7545         if (len>count) len = count;
7546         if (len<0) len = 0;
7547         return len;
7548 }
7549
7550
7551 static void cleanup(void)
7552 {
7553         int cnt;
7554         IXJ *j;
7555
7556         for (cnt = 0; cnt < IXJMAX; cnt++) {
7557                 j = get_ixj(cnt);
7558                 if(j != NULL && j->DSPbase) {
7559                         if (ixjdebug & 0x0002)
7560                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7561                         del_timer(&j->timer);
7562                         if (j->cardtype == QTI_LINEJACK) {
7563                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7564
7565                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7566                                 j->pld_slicw.bits.rly1 = 0;
7567                                 j->pld_slicw.bits.rly2 = 0;
7568                                 j->pld_slicw.bits.rly3 = 0;
7569                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7570                                 LED_SetState(0x0, j);
7571                                 if (ixjdebug & 0x0002)
7572                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7573                                 release_region(j->XILINXbase, 8);
7574                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7575                                 if (ixjdebug & 0x0002)
7576                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7577                                 release_region(j->XILINXbase, 4);
7578                         }
7579                         if (j->read_buffer)
7580                                 kfree(j->read_buffer);
7581                         if (j->write_buffer)
7582                                 kfree(j->write_buffer);
7583                         if (j->dev)
7584                                 pnp_device_detach(j->dev);
7585                         if (ixjdebug & 0x0002)
7586                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7587                         phone_unregister_device(&j->p);
7588                         if (ixjdebug & 0x0002)
7589                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7590                         release_region(j->DSPbase, 16);
7591 #ifdef IXJ_DYN_ALLOC
7592                         if (ixjdebug & 0x0002)
7593                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7594                         kfree(j);
7595                         ixj[cnt] = NULL;
7596 #endif
7597                 }
7598         }
7599         if (ixjdebug & 0x0002)
7600                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7601         remove_proc_entry ("ixj", NULL);
7602 }
7603
7604 /* Typedefs */
7605 typedef struct {
7606         BYTE length;
7607         DWORD bits;
7608 } DATABLOCK;
7609
7610 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7611 {
7612         lastLCC = lastLCC & 0xfb;
7613         lastLCC = lastLCC | (byData ? 4 : 0);
7614         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7615
7616         mdelay(1);
7617         lastLCC = lastLCC | 0x01;
7618         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7619
7620         byData = byData << 1;
7621         lastLCC = lastLCC & 0xfe;
7622         mdelay(1);
7623         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7624
7625 }
7626
7627 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7628 {
7629         mdelay(1);
7630         lastLCC = lastLCC | 0x01;
7631         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7632
7633         lastLCC = lastLCC & 0xfe;
7634         mdelay(1);
7635         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7636
7637         return ((inb(wEEPROMAddress) >> 3) & 1);
7638 }
7639
7640 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7641 {
7642         BYTE lastLCC;
7643         WORD wEEPROMAddress = wAddress + 3;
7644         DWORD i;
7645         BYTE byResult;
7646         *pwResult = 0;
7647         lastLCC = inb(wEEPROMAddress);
7648         lastLCC = lastLCC | 0x02;
7649         lastLCC = lastLCC & 0xfe;
7650         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7651
7652         mdelay(1);              /* delay */
7653
7654         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7655         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7656         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7657         for (i = 0; i < 8; i++) {
7658                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7659                 wLoc <<= 1;
7660         }
7661
7662         for (i = 0; i < 16; i++) {
7663                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7664                 *pwResult = (*pwResult << 1) | byResult;
7665         }
7666
7667         mdelay(1);              /* another delay */
7668
7669         lastLCC = lastLCC & 0xfd;
7670         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7671
7672         return 0;
7673 }
7674
7675 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7676 {
7677         WORD wLo, wHi;
7678         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7679                 return 0;
7680         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7681                 return 0;
7682         return (((DWORD) wHi << 16) | wLo);
7683 }
7684
7685 static int dspio[IXJMAX + 1] =
7686 {
7687         0,
7688 };
7689 static int xio[IXJMAX + 1] =
7690 {
7691         0,
7692 };
7693
7694 MODULE_PARM(dspio, "1-" __MODULE_STRING(IXJMAX) "i");
7695 MODULE_PARM(xio, "1-" __MODULE_STRING(IXJMAX) "i");
7696 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7697 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7698 MODULE_LICENSE("GPL");
7699
7700 static void __exit ixj_exit(void)
7701 {
7702         cleanup();
7703 }
7704
7705 int __init ixj_probe_isapnp(int *cnt)
7706 {
7707         int probe = 0;
7708         int func = 0x110;
7709         struct pnp_dev *dev = NULL, *old_dev = NULL;
7710
7711         while (1) {
7712                 do {
7713                         IXJ *j;
7714                         int result;
7715
7716                         old_dev = dev;
7717                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7718                                          ISAPNP_FUNCTION(func), old_dev);
7719                         if (!dev || !dev->card)
7720                                 break;
7721                         result = pnp_device_attach(dev);
7722                         if (result < 0) {
7723                                 printk("pnp attach failed %d \n", result);
7724                                 break;
7725                         }
7726                         if (pnp_activate_dev(dev) < 0) {
7727                                 printk("pnp activate failed (out of resources?)\n");
7728                                 pnp_device_detach(dev);
7729                                 return -ENOMEM;
7730                         }
7731
7732                         if (!pnp_port_valid(dev, 0)) {
7733                                 pnp_device_detach(dev);
7734                                 return -ENODEV;
7735                         }
7736
7737                         result = check_region(pnp_port_start(dev, 0), 16);
7738                         if (result) {
7739                                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", pnp_port_start(dev, 0));
7740                                 break;
7741                         }
7742
7743                         j = ixj_alloc();
7744                         request_region(j->DSPbase, 16, "ixj DSP");
7745
7746                         if (func != 0x110)
7747                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7748
7749                         switch (func) {
7750                         case (0x110):
7751                                 j->cardtype = QTI_PHONEJACK;
7752                                 break;
7753                         case (0x310):
7754                                 j->cardtype = QTI_LINEJACK;
7755                                 break;
7756                         case (0x410):
7757                                 j->cardtype = QTI_PHONEJACK_LITE;
7758                                 break;
7759                         }
7760                         j->board = *cnt;
7761                         probe = ixj_selfprobe(j);
7762                         if(!probe) {
7763                                 j->serial = dev->card->serial;
7764                                 j->dev = dev;
7765                                 switch (func) {
7766                                 case 0x110:
7767                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7768                                         break;
7769                                 case 0x310:
7770                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7771                                         break;
7772                                 case 0x410:
7773                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7774                                         break;
7775                                 }
7776                         }
7777                         ++*cnt;
7778                 } while (dev);
7779                 if (func == 0x410)
7780                         break;
7781                 if (func == 0x310)
7782                         func = 0x410;
7783                 if (func == 0x110)
7784                         func = 0x310;
7785                 dev = NULL;
7786         }
7787         return probe;
7788 }
7789
7790 int __init ixj_probe_isa(int *cnt)
7791 {
7792         int i, result, probe;
7793
7794         /* Use passed parameters for older kernels without PnP */
7795         for (i = 0; i < IXJMAX; i++) {
7796                 if (dspio[i]) {
7797                         IXJ *j;
7798
7799                         if ((result = check_region(ixj[*cnt].DSPbase, 16)) < 0) {
7800                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", ixj[*cnt].DSPbase);
7801                                 break;
7802                         }
7803
7804                         j = ixj_alloc();
7805
7806                         j->DSPbase = dspio[i];
7807                         request_region(j->DSPbase, 16, "ixj DSP");
7808
7809                         j->XILINXbase = xio[i];
7810                         j->cardtype = 0;
7811
7812                         j->board = *cnt;
7813                         probe = ixj_selfprobe(j);
7814                         j->dev = NULL;
7815                         ++*cnt;
7816                 }
7817         }
7818         return 0;
7819 }
7820
7821 int __init ixj_probe_pci(int *cnt)
7822 {
7823         struct pci_dev *pci = NULL;
7824         int i, probe = 0;
7825         IXJ *j = NULL;
7826         int result;
7827
7828         for (i = 0; i < IXJMAX - *cnt; i++) {
7829                 pci = pci_find_device(0x15E2, 0x0500, pci);
7830                 if (!pci)
7831                         break;
7832
7833                 if (pci_enable_device(pci))
7834                         break;
7835                 if ((result = check_region(pci_resource_start(pci, 0), 16)) < 0) {
7836                         printk(KERN_INFO "ixj: can't get I/O address\n");
7837                         break;
7838                 }
7839
7840                 /* Grab a device slot */
7841                 j = ixj_alloc();
7842                 if(j == NULL)
7843                         break;
7844
7845                 j->DSPbase = pci_resource_start(pci, 0);
7846                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7847                 j->XILINXbase = j->DSPbase + 0x10;
7848                 request_region(j->DSPbase, 16, "ixj DSP");
7849                 j->cardtype = QTI_PHONEJACK_PCI;
7850                 j->board = *cnt;
7851                 probe = ixj_selfprobe(j);
7852                 if (!probe)
7853                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7854                 ++*cnt;
7855         }
7856         return probe;
7857 }
7858
7859 static int __init ixj_init(void)
7860 {
7861         int cnt = 0;
7862         int probe = 0;
7863
7864         cnt = 0;
7865
7866         /* These might be no-ops, see above. */
7867         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7868                 return probe;
7869         }
7870         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7871                 return probe;
7872         }
7873         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7874                 return probe;
7875         }
7876         printk("%s\n", ixj_c_rcsid);
7877         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7878         return probe;
7879 }
7880
7881 module_init(ixj_init);
7882 module_exit(ixj_exit);
7883
7884 static void DAA_Coeff_US(IXJ *j)
7885 {
7886         int i;
7887
7888         j->daa_country = DAA_US;
7889         /*----------------------------------------------- */
7890         /* CAO */
7891         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7892                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7893         }
7894
7895 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7896         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7897         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7898         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7899         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7900         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7901         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7902         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7903         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7904 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7905         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7906         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7907         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7908         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7909         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7910         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7911         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7912         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7913 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7914         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7915         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7916         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7917         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7918         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7919         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7920         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7921         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7922 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7923         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7924         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7925         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7926         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7927         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7928         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7929         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7930         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7931 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7932         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7933         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7934         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7935         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7936 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7937         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7938         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7939         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7940         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7941 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7942         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7943         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7944         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7945         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7946         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7947         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7948         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7949         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7950 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7951         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7952         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7953         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7954         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7955         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7956         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7957         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7958         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7959 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7960         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7961         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7962         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7963         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7964         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7965         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7966         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7967         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7968 /* ;  (10K, 0.68uF) */
7969         /*  */
7970         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7971         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7972         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7973         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7974         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7975         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7976         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7977         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7978         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7979         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7980         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7981         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7982         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7983         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7984         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7985         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7986         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7987         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7988
7989         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7990         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7991         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7992         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7993         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7994
7995         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7996 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7997 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7998 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7999 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
8000 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
8001 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
8002 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
8003 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
8004         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8005 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
8006 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
8007 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
8008 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
8009 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
8010 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
8011 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
8012 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
8013 /* */
8014         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8015 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
8016 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
8017 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
8018 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
8019
8020         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8021         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8022         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8023         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8024         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8025         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8026         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8027         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8028         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8029 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8030         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8031         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8032         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8033         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8034         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8035         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8036         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8037         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8038 /*  */
8039         /* ;CR Registers */
8040         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
8041         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8042 /* Config. Reg. 1 (dialing)       (cr1):05 */
8043         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8044 /* Config. Reg. 2 (caller ID)     (cr2):04 */
8045         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8046 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
8047         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8048 /* Config. Reg. 4 (analog gain)   (cr4):02 */
8049         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8050         /* Config. Reg. 5 (Version)       (cr5):02 */
8051         /* Config. Reg. 6 (Reserved)      (cr6):00 */
8052         /* Config. Reg. 7 (Reserved)      (cr7):00 */
8053         /*  */
8054         /* ;xr Registers */
8055         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
8056
8057         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8058         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
8059
8060         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
8061 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8062         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8063 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
8064         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
8065         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
8066
8067         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8068 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
8069         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8070 /* Ext. Reg. 6 (Power State)      (xr6):00 */
8071         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8072 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
8073         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8074         /*  */
8075         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
8076         /*                                       12,33,5A,C3 ;  770 Hz   */
8077         /*                                       13,3C,5B,32 ;  852 Hz   */
8078         /*                                       1D,1B,5C,CC ;  941 Hz   */
8079
8080         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8081         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8082         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8083         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8084 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
8085         /*                                       EC,1D,52,22 ;  1336 Hz   */
8086         /*                                       AA,AC,51,D2 ;  1477 Hz   */
8087         /*                                       9B,3B,51,25 ;  1633 Hz   */
8088         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8089         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8090         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8091         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8092 }
8093
8094 static void DAA_Coeff_UK(IXJ *j)
8095 {
8096         int i;
8097
8098         j->daa_country = DAA_UK;
8099         /*----------------------------------------------- */
8100         /* CAO */
8101         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8102                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8103         }
8104
8105 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8106         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8107         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8108         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8109         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8110         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8111         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8112         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8113         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8114 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8115         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8116         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8117         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8118         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8119         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8120         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8121         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8122         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8123 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
8124         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8125         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8126         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8127         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8128         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8129         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8130         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8131         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8132 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8133         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8134         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8135         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8136         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8137         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8138         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8139         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8140         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8141 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8142         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8143         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8144         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8145         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8146 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8147         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8148         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8149         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8150         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8151 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8152         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8153         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8154         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8155         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8156         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8157         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8158         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8159         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8160 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8161         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8162         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8163         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8164         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8165         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8166         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8167         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8168         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8169 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8170         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8171         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8172         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8173         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8174         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8175         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8176         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8177         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8178 /* ; idle */
8179         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8180         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8181         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8182         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8183         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8184         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8185         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8186         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8187         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8188 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8189         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8190         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8191         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8192         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8193         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8194         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8195         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8196         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8197 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8198         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8199         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8200         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8201         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8202 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8203         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8204         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8205         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8206         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8207         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8208         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8209         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8210         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8211 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8212         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8213         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8214         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8215         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8216         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8217         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8218         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8219         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8220 /* ;CR Registers */
8221         /* Config. Reg. 0 (filters)        (cr0):FF */
8222         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8223 /* Config. Reg. 1 (dialing)        (cr1):05 */
8224         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8225 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8226         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8227 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8228         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8229 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8230         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8231         /* Config. Reg. 5 (Version)        (cr5):02 */
8232         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8233         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8234         /* ;xr Registers */
8235         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8236
8237         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8238         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8239
8240         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8241         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8242
8243         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8244 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8245         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8246 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8247         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8248 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8249         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8250 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8251         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8252 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8253         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8254         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8255         /*                                       12,33,5A,C3    ;  770 Hz   */
8256         /*                                       13,3C,5B,32    ;  852 Hz   */
8257         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8258
8259         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8260         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8261         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8262         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8263 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8264         /*                                       EC,1D,52,22    ;  1336 Hz   */
8265         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8266         /*                                       9B,3B,51,25    ;  1633 Hz   */
8267         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8268         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8269         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8270         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8271 }
8272
8273
8274 static void DAA_Coeff_France(IXJ *j)
8275 {
8276         int i;
8277
8278         j->daa_country = DAA_FRANCE;
8279         /*----------------------------------------------- */
8280         /* CAO */
8281         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8282                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8283         }
8284
8285 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8286         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8287         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8288         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8289         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8290         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8291         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8292         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8293         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8294 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8295         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8296         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8297         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8298         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8299         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8300         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8301         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8302         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8303 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8304         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8305         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8306         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8307         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8308         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8309         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8310         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8311         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8312 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8313         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8314         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8315         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8316         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8317         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8318         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8319         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8320         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8321 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8322         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8323         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8324         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8325         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8326 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8327         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8328         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8329         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8330         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8331 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8332         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8333         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8334         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8335         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8336         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8337         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8338         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8339         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8340 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8341         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8342         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8343         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8344         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8345         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8346         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8347         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8348         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8349 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8350         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8351         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8352         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8353         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8354         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8355         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8356         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8357         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8358 /* ; idle */
8359         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8360         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8361         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8362         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8363         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8364         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8365         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8366         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8367         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8368 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8369         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8370         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8371         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8372         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8373         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8374         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8375         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8376         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8377 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8378         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8379         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8380         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8381         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8382 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8383         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8384         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8385         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8386         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8387         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8388         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8389         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8390         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8391 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8392         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8393         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8394         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8395         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8396         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8397         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8398         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8399         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8400 /* ;CR Registers */
8401         /* Config. Reg. 0 (filters)        (cr0):FF */
8402         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8403 /* Config. Reg. 1 (dialing)        (cr1):05 */
8404         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8405 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8406         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8407 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8408         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8409 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8410         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8411         /* Config. Reg. 5 (Version)        (cr5):02 */
8412         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8413         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8414         /* ;xr Registers */
8415         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8416
8417         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8418         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8419
8420         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8421         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8422
8423         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8424 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8425         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8426 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8427         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8428 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8429         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8430 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8431         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8432 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8433         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8434         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8435         /*                                       12,33,5A,C3    ;  770 Hz   */
8436         /*                                       13,3C,5B,32    ;  852 Hz   */
8437         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8438
8439         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8440         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8441         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8442         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8443 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8444         /*                                       EC,1D,52,22    ;  1336 Hz   */
8445         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8446         /*                                       9B,3B,51,25    ;  1633 Hz   */
8447         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8448         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8449         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8450         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8451 }
8452
8453
8454 static void DAA_Coeff_Germany(IXJ *j)
8455 {
8456         int i;
8457
8458         j->daa_country = DAA_GERMANY;
8459         /*----------------------------------------------- */
8460         /* CAO */
8461         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8462                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8463         }
8464
8465 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8466         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8467         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8468         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8469         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8470         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8471         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8472         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8473         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8474 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8475         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8476         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8477         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8478         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8479         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8480         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8481         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8482         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8483 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8484         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8485         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8486         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8487         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8488         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8489         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8490         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8491         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8492 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8493         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8494         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8495         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8496         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8497         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8498         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8499         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8500         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8501 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8502         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8503         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8504         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8505         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8506 /* Bytes for AR-filter        (09): 72,42,13,4B */
8507         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8508         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8509         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8510         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8511 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8512         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8513         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8514         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8515         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8516         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8517         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8518         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8519         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8520 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8521         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8522         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8523         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8524         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8525         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8526         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8527         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8528         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8529 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8530         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8531         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8532         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8533         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8534         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8535         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8536         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8537         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8538 /* ;  (10K, 0.68uF) */
8539         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8540         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8541         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8542         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8543         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8544         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8545         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8546         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8547         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8548 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8549         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8550         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8551         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8552         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8553         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8554         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8555         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8556         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8557 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8558         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8559         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8560         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8561         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8562 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8563         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8564         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8565         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8566         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8567         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8568         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8569         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8570         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8571 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8572         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8573         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8574         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8575         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8576         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8577         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8578         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8579         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8580 /* ;CR Registers */
8581         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8582         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8583 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8584         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8585 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8586         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8587 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8588         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8589 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8590         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8591         /* Config. Reg. 5 (Version)        (cr5):02 */
8592         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8593         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8594         /* ;xr Registers */
8595         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8596
8597         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8598         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8599
8600         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8601         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8602
8603         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8604 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8605         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8606 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8607         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8608 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8609         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8610 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8611         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8612 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8613         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8614         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8615         /*                                       12,33,5A,C3    ;  770 Hz   */
8616         /*                                       13,3C,5B,32    ;  852 Hz   */
8617         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8618
8619         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8620         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8621         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8622         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8623 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8624         /*                                       EC,1D,52,22    ;  1336 Hz   */
8625         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8626         /*                                       9B,3B,51,25    ;  1633 Hz   */
8627         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8628         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8629         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8630         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8631 }
8632
8633
8634 static void DAA_Coeff_Australia(IXJ *j)
8635 {
8636         int i;
8637
8638         j->daa_country = DAA_AUSTRALIA;
8639         /*----------------------------------------------- */
8640         /* CAO */
8641         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8642                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8643         }
8644
8645 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8646         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8647         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8648         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8649         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8650         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8651         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8652         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8653         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8654 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8655         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8656         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8657         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8658         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8659         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8660         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8661         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8662         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8663 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8664         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8665         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8666         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8667         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8668         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8669         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8670         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8671         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8672 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8673         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8674         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8675         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8676         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8677         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8678         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8679         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8680         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8681 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8682         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8683         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8684         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8685         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8686 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8687         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8688         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8689         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8690         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8691 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8692         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8693         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8694         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8695         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8696         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8697         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8698         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8699         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8700 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8701         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8702         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8703         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8704         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8705         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8706         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8707         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8708         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8709 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8710         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8711         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8712         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8713         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8714         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8715         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8716         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8717         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8718 /* ;  idle */
8719         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8720         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8721         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8722         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8723         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8724         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8725         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8726         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8727         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8728 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8729         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8730         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8731         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8732         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8733         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8734         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8735         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8736         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8737 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8738         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8739         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8740         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8741         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8742 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8743         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8744         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8745         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8746         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8747         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8748         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8749         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8750         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8751 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8752         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8753         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8754         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8755         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8756         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8757         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8758         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8759         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8760 /* ;CR Registers */
8761         /* Config. Reg. 0 (filters)        (cr0):FF */
8762         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8763 /* Config. Reg. 1 (dialing)        (cr1):05 */
8764         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8765 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8766         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8767 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8768         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8769 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8770         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8771         /* Config. Reg. 5 (Version)        (cr5):02 */
8772         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8773         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8774         /* ;xr Registers */
8775         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8776
8777         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8778         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8779
8780         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8781         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8782
8783         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8784 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8785         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8786 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8787         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8788 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8789         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8790 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8791         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8792 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8793         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8794
8795         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8796         /*                                       12,33,5A,C3    ;  770 Hz   */
8797         /*                                       13,3C,5B,32    ;  852 Hz   */
8798         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8799         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8800         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8801         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8802         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8803
8804         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8805         /*                                       EC,1D,52,22    ;  1336 Hz   */
8806         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8807         /*                                       9B,3B,51,25    ;  1633 Hz   */
8808         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8809         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8810         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8811         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8812 }
8813
8814 static void DAA_Coeff_Japan(IXJ *j)
8815 {
8816         int i;
8817
8818         j->daa_country = DAA_JAPAN;
8819         /*----------------------------------------------- */
8820         /* CAO */
8821         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8822                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8823         }
8824
8825 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8826         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8827         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8828         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8829         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8830         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8831         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8832         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8833         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8834 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8835         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8836         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8837         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8838         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8839         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8840         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8841         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8842         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8843 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8844         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8845         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8846         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8847         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8848         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8849         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8850         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8851         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8852 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8853         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8854         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8855         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8856         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8857         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8858         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8859         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8860         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8861 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8862         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8863         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8864         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8865         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8866 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8867         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8868         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8869         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8870         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8871 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8872         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8873         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8874         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8875         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8876         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8877         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8878         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8879         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8880 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8881         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8882         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8883         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8884         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8885         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8886         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8887         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8888         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8889 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8890         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8891         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8892         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8893         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8894         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8895         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8896         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8897         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8898 /* ;  idle */
8899         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8900         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8901         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8902         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8903         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8904         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8905         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8906         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8907         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8908 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8909         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8910         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8911         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8912         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8913         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8914         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8915         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8916         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8917 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8918         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8919         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8920         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8921         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8922 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8923         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8924         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8925         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8926         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8927         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8928         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8929         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8930         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8931 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8932         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8933         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8934         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8935         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8936         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8937         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8938         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8939         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8940 /* ;CR Registers */
8941         /* Config. Reg. 0 (filters)        (cr0):FF */
8942         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8943 /* Config. Reg. 1 (dialing)        (cr1):05 */
8944         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8945 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8946         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8947 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8948         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8949 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8950         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8951         /* Config. Reg. 5 (Version)        (cr5):02 */
8952         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8953         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8954         /* ;xr Registers */
8955         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8956
8957         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8958         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8959
8960         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8961         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8962
8963         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8964 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8965         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8966 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8967         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8968 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8969         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8970 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8971         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8972 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8973         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8974         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8975         /*                                       12,33,5A,C3    ;  770 Hz   */
8976         /*                                       13,3C,5B,32    ;  852 Hz   */
8977         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8978
8979         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8980         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8981         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8982         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8983 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8984         /*                                       EC,1D,52,22    ;  1336 Hz   */
8985         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8986         /*                                       9B,3B,51,25    ;  1633 Hz   */
8987         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8988         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8989         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8990         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8991 }
8992
8993 static s16 tone_table[][19] =
8994 {
8995         {                       /* f20_50[] 11 */
8996                 32538,          /* A1 = 1.985962 */
8997                  -32325,        /* A2 = -0.986511 */
8998                  -343,          /* B2 = -0.010493 */
8999                  0,             /* B1 = 0 */
9000                  343,           /* B0 = 0.010493 */
9001                  32619,         /* A1 = 1.990906 */
9002                  -32520,        /* A2 = -0.992462 */
9003                  19179,         /* B2 = 0.585327 */
9004                  -19178,        /* B1 = -1.170593 */
9005                  19179,         /* B0 = 0.585327 */
9006                  32723,         /* A1 = 1.997314 */
9007                  -32686,        /* A2 = -0.997528 */
9008                  9973,          /* B2 = 0.304352 */
9009                  -9955,         /* B1 = -0.607605 */
9010                  9973,          /* B0 = 0.304352 */
9011                  7,             /* Internal filter scaling */
9012                  159,           /* Minimum in-band energy threshold */
9013                  21,            /* 21/32 in-band to broad-band ratio */
9014                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9015         },
9016         {                       /* f133_200[] 12 */
9017                 32072,          /* A1 = 1.95752 */
9018                  -31896,        /* A2 = -0.973419 */
9019                  -435,          /* B2 = -0.013294 */
9020                  0,             /* B1 = 0 */
9021                  435,           /* B0 = 0.013294 */
9022                  32188,         /* A1 = 1.9646 */
9023                  -32400,        /* A2 = -0.98877 */
9024                  15139,         /* B2 = 0.462036 */
9025                  -14882,        /* B1 = -0.908356 */
9026                  15139,         /* B0 = 0.462036 */
9027                  32473,         /* A1 = 1.981995 */
9028                  -32524,        /* A2 = -0.992584 */
9029                  23200,         /* B2 = 0.708008 */
9030                  -23113,        /* B1 = -1.410706 */
9031                  23200,         /* B0 = 0.708008 */
9032                  7,             /* Internal filter scaling */
9033                  159,           /* Minimum in-band energy threshold */
9034                  21,            /* 21/32 in-band to broad-band ratio */
9035                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9036         },
9037         {                       /* f300 13 */
9038                 31769,          /* A1 = -1.939026 */
9039                  -32584,        /* A2 = 0.994385 */
9040                  -475,          /* B2 = -0.014522 */
9041                  0,             /* B1 = 0.000000 */
9042                  475,           /* B0 = 0.014522 */
9043                  31789,         /* A1 = -1.940247 */
9044                  -32679,        /* A2 = 0.997284 */
9045                  17280,         /* B2 = 0.527344 */
9046                  -16865,        /* B1 = -1.029358 */
9047                  17280,         /* B0 = 0.527344 */
9048                  31841,         /* A1 = -1.943481 */
9049                  -32681,        /* A2 = 0.997345 */
9050                  543,           /* B2 = 0.016579 */
9051                  -525,          /* B1 = -0.032097 */
9052                  543,           /* B0 = 0.016579 */
9053                  5,             /* Internal filter scaling */
9054                  159,           /* Minimum in-band energy threshold */
9055                  21,            /* 21/32 in-band to broad-band ratio */
9056                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9057         },
9058         {                       /* f300_420[] 14 */
9059                 30750,          /* A1 = 1.876892 */
9060                  -31212,        /* A2 = -0.952515 */
9061                  -804,          /* B2 = -0.024541 */
9062                  0,             /* B1 = 0 */
9063                  804,           /* B0 = 0.024541 */
9064                  30686,         /* A1 = 1.872925 */
9065                  -32145,        /* A2 = -0.980988 */
9066                  14747,         /* B2 = 0.450043 */
9067                  -13703,        /* B1 = -0.836395 */
9068                  14747,         /* B0 = 0.450043 */
9069                  31651,         /* A1 = 1.931824 */
9070                  -32321,        /* A2 = -0.986389 */
9071                  24425,         /* B2 = 0.745422 */
9072                  -23914,        /* B1 = -1.459595 */
9073                  24427,         /* B0 = 0.745483 */
9074                  7,             /* Internal filter scaling */
9075                  159,           /* Minimum in-band energy threshold */
9076                  21,            /* 21/32 in-band to broad-band ratio */
9077                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9078         },
9079         {                       /* f330 15 */
9080                 31613,          /* A1 = -1.929565 */
9081                  -32646,        /* A2 = 0.996277 */
9082                  -185,          /* B2 = -0.005657 */
9083                  0,             /* B1 = 0.000000 */
9084                  185,           /* B0 = 0.005657 */
9085                  31620,         /* A1 = -1.929932 */
9086                  -32713,        /* A2 = 0.998352 */
9087                  19253,         /* B2 = 0.587585 */
9088                  -18566,        /* B1 = -1.133179 */
9089                  19253,         /* B0 = 0.587585 */
9090                  31674,         /* A1 = -1.933228 */
9091                  -32715,        /* A2 = 0.998413 */
9092                  2575,          /* B2 = 0.078590 */
9093                  -2495,         /* B1 = -0.152283 */
9094                  2575,          /* B0 = 0.078590 */
9095                  5,             /* Internal filter scaling */
9096                  159,           /* Minimum in-band energy threshold */
9097                  21,            /* 21/32 in-band to broad-band ratio */
9098                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9099         },
9100         {                       /* f300_425[] 16 */
9101                 30741,          /* A1 = 1.876282 */
9102                  -31475,        /* A2 = -0.960541 */
9103                  -703,          /* B2 = -0.021484 */
9104                  0,             /* B1 = 0 */
9105                  703,           /* B0 = 0.021484 */
9106                  30688,         /* A1 = 1.873047 */
9107                  -32248,        /* A2 = -0.984161 */
9108                  14542,         /* B2 = 0.443787 */
9109                  -13523,        /* B1 = -0.825439 */
9110                  14542,         /* B0 = 0.443817 */
9111                  31494,         /* A1 = 1.922302 */
9112                  -32366,        /* A2 = -0.987762 */
9113                  21577,         /* B2 = 0.658508 */
9114                  -21013,        /* B1 = -1.282532 */
9115                  21577,         /* B0 = 0.658508 */
9116                  7,             /* Internal filter scaling */
9117                  159,           /* Minimum in-band energy threshold */
9118                  21,            /* 21/32 in-band to broad-band ratio */
9119                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9120         },
9121         {                       /* f330_440[] 17 */
9122                 30627,          /* A1 = 1.869324 */
9123                  -31338,        /* A2 = -0.95636 */
9124                  -843,          /* B2 = -0.025749 */
9125                  0,             /* B1 = 0 */
9126                  843,           /* B0 = 0.025749 */
9127                  30550,         /* A1 = 1.864685 */
9128                  -32221,        /* A2 = -0.983337 */
9129                  13594,         /* B2 = 0.414886 */
9130                  -12589,        /* B1 = -0.768402 */
9131                  13594,         /* B0 = 0.414886 */
9132                  31488,         /* A1 = 1.921936 */
9133                  -32358,        /* A2 = -0.987518 */
9134                  24684,         /* B2 = 0.753296 */
9135                  -24029,        /* B1 = -1.466614 */
9136                  24684,         /* B0 = 0.753296 */
9137                  7,             /* Internal filter scaling */
9138                  159,           /* Minimum in-band energy threshold */
9139                  21,            /* 21/32 in-band to broad-band ratio */
9140                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9141         },
9142         {                       /* f340 18 */
9143                 31546,          /* A1 = -1.925476 */
9144                  -32646,        /* A2 = 0.996277 */
9145                  -445,          /* B2 = -0.013588 */
9146                  0,             /* B1 = 0.000000 */
9147                  445,           /* B0 = 0.013588 */
9148                  31551,         /* A1 = -1.925781 */
9149                  -32713,        /* A2 = 0.998352 */
9150                  23884,         /* B2 = 0.728882 */
9151                  -22979,        /* B1 = -1.402527 */
9152                  23884,         /* B0 = 0.728882 */
9153                  31606,         /* A1 = -1.929138 */
9154                  -32715,        /* A2 = 0.998413 */
9155                  863,           /* B2 = 0.026367 */
9156                  -835,          /* B1 = -0.050985 */
9157                  863,           /* B0 = 0.026367 */
9158                  5,             /* Internal filter scaling */
9159                  159,           /* Minimum in-band energy threshold */
9160                  21,            /* 21/32 in-band to broad-band ratio */
9161                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9162         },
9163         {                       /* f350_400[] 19 */
9164                 31006,          /* A1 = 1.892517 */
9165                  -32029,        /* A2 = -0.977448 */
9166                  -461,          /* B2 = -0.014096 */
9167                  0,             /* B1 = 0 */
9168                  461,           /* B0 = 0.014096 */
9169                  30999,         /* A1 = 1.892029 */
9170                  -32487,        /* A2 = -0.991455 */
9171                  11325,         /* B2 = 0.345612 */
9172                  -10682,        /* B1 = -0.651978 */
9173                  11325,         /* B0 = 0.345612 */
9174                  31441,         /* A1 = 1.919067 */
9175                  -32526,        /* A2 = -0.992615 */
9176                  24324,         /* B2 = 0.74231 */
9177                  -23535,        /* B1 = -1.436523 */
9178                  24324,         /* B0 = 0.74231 */
9179                  7,             /* Internal filter scaling */
9180                  159,           /* Minimum in-band energy threshold */
9181                  21,            /* 21/32 in-band to broad-band ratio */
9182                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9183         },
9184         {                       /* f350_440[] */
9185                 30634,          /* A1 = 1.869751 */
9186                  -31533,        /* A2 = -0.962341 */
9187                  -680,          /* B2 = -0.020782 */
9188                  0,             /* B1 = 0 */
9189                  680,           /* B0 = 0.020782 */
9190                  30571,         /* A1 = 1.865906 */
9191                  -32277,        /* A2 = -0.985016 */
9192                  12894,         /* B2 = 0.393524 */
9193                  -11945,        /* B1 = -0.729065 */
9194                  12894,         /* B0 = 0.393524 */
9195                  31367,         /* A1 = 1.91449 */
9196                  -32379,        /* A2 = -0.988129 */
9197                  23820,         /* B2 = 0.726929 */
9198                  -23104,        /* B1 = -1.410217 */
9199                  23820,         /* B0 = 0.726929 */
9200                  7,             /* Internal filter scaling */
9201                  159,           /* Minimum in-band energy threshold */
9202                  21,            /* 21/32 in-band to broad-band ratio */
9203                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9204         },
9205         {                       /* f350_450[] */
9206                 30552,          /* A1 = 1.864807 */
9207                  -31434,        /* A2 = -0.95929 */
9208                  -690,          /* B2 = -0.021066 */
9209                  0,             /* B1 = 0 */
9210                  690,           /* B0 = 0.021066 */
9211                  30472,         /* A1 = 1.859924 */
9212                  -32248,        /* A2 = -0.984161 */
9213                  13385,         /* B2 = 0.408478 */
9214                  -12357,        /* B1 = -0.754242 */
9215                  13385,         /* B0 = 0.408478 */
9216                  31358,         /* A1 = 1.914001 */
9217                  -32366,        /* A2 = -0.987732 */
9218                  26488,         /* B2 = 0.80835 */
9219                  -25692,        /* B1 = -1.568176 */
9220                  26490,         /* B0 = 0.808411 */
9221                  7,             /* Internal filter scaling */
9222                  159,           /* Minimum in-band energy threshold */
9223                  21,            /* 21/32 in-band to broad-band ratio */
9224                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9225         },
9226         {                       /* f360 */
9227                 31397,          /* A1 = -1.916321 */
9228                  -32623,        /* A2 = 0.995605 */
9229                  -117,          /* B2 = -0.003598 */
9230                  0,             /* B1 = 0.000000 */
9231                  117,           /* B0 = 0.003598 */
9232                  31403,         /* A1 = -1.916687 */
9233                  -32700,        /* A2 = 0.997925 */
9234                  3388,          /* B2 = 0.103401 */
9235                  -3240,         /* B1 = -0.197784 */
9236                  3388,          /* B0 = 0.103401 */
9237                  31463,         /* A1 = -1.920410 */
9238                  -32702,        /* A2 = 0.997986 */
9239                  13346,         /* B2 = 0.407288 */
9240                  -12863,        /* B1 = -0.785126 */
9241                  13346,         /* B0 = 0.407288 */
9242                  5,             /* Internal filter scaling */
9243                  159,           /* Minimum in-band energy threshold */
9244                  21,            /* 21/32 in-band to broad-band ratio */
9245                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9246         },
9247         {                       /* f380_420[] */
9248                 30831,          /* A1 = 1.881775 */
9249                  -32064,        /* A2 = -0.978546 */
9250                  -367,          /* B2 = -0.01122 */
9251                  0,             /* B1 = 0 */
9252                  367,           /* B0 = 0.01122 */
9253                  30813,         /* A1 = 1.880737 */
9254                  -32456,        /* A2 = -0.990509 */
9255                  11068,         /* B2 = 0.337769 */
9256                  -10338,        /* B1 = -0.631042 */
9257                  11068,         /* B0 = 0.337769 */
9258                  31214,         /* A1 = 1.905212 */
9259                  -32491,        /* A2 = -0.991577 */
9260                  16374,         /* B2 = 0.499695 */
9261                  -15781,        /* B1 = -0.963196 */
9262                  16374,         /* B0 = 0.499695 */
9263                  7,             /* Internal filter scaling */
9264                  159,           /* Minimum in-band energy threshold */
9265                  21,            /* 21/32 in-band to broad-band ratio */
9266                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9267         },
9268         {                       /* f392 */
9269                 31152,          /* A1 = -1.901428 */
9270                  -32613,        /* A2 = 0.995300 */
9271                  -314,          /* B2 = -0.009605 */
9272                  0,             /* B1 = 0.000000 */
9273                  314,           /* B0 = 0.009605 */
9274                  31156,         /* A1 = -1.901672 */
9275                  -32694,        /* A2 = 0.997742 */
9276                  28847,         /* B2 = 0.880371 */
9277                  -2734,         /* B1 = -0.166901 */
9278                  28847,         /* B0 = 0.880371 */
9279                  31225,         /* A1 = -1.905823 */
9280                  -32696,        /* A2 = 0.997803 */
9281                  462,           /* B2 = 0.014108 */
9282                  -442,          /* B1 = -0.027019 */
9283                  462,           /* B0 = 0.014108 */
9284                  5,             /* Internal filter scaling */
9285                  159,           /* Minimum in-band energy threshold */
9286                  21,            /* 21/32 in-band to broad-band ratio */
9287                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9288         },
9289         {                       /* f400_425[] */
9290                 30836,          /* A1 = 1.882141 */
9291                  -32296,        /* A2 = -0.985596 */
9292                  -324,          /* B2 = -0.009903 */
9293                  0,             /* B1 = 0 */
9294                  324,           /* B0 = 0.009903 */
9295                  30825,         /* A1 = 1.881409 */
9296                  -32570,        /* A2 = -0.993958 */
9297                  16847,         /* B2 = 0.51416 */
9298                  -15792,        /* B1 = -0.963898 */
9299                  16847,         /* B0 = 0.51416 */
9300                  31106,         /* A1 = 1.89856 */
9301                  -32584,        /* A2 = -0.994415 */
9302                  9579,          /* B2 = 0.292328 */
9303                  -9164,         /* B1 = -0.559357 */
9304                  9579,          /* B0 = 0.292328 */
9305                  7,             /* Internal filter scaling */
9306                  159,           /* Minimum in-band energy threshold */
9307                  21,            /* 21/32 in-band to broad-band ratio */
9308                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9309         },
9310         {                       /* f400_440[] */
9311                 30702,          /* A1 = 1.873962 */
9312                  -32134,        /* A2 = -0.980682 */
9313                  -517,          /* B2 = -0.015793 */
9314                  0,             /* B1 = 0 */
9315                  517,           /* B0 = 0.015793 */
9316                  30676,         /* A1 = 1.872375 */
9317                  -32520,        /* A2 = -0.992462 */
9318                  8144,          /* B2 = 0.24855 */
9319                  -7596,         /* B1 = -0.463684 */
9320                  8144,          /* B0 = 0.24855 */
9321                  31084,         /* A1 = 1.897217 */
9322                  -32547,        /* A2 = -0.993256 */
9323                  22713,         /* B2 = 0.693176 */
9324                  -21734,        /* B1 = -1.326599 */
9325                  22713,         /* B0 = 0.693176 */
9326                  7,             /* Internal filter scaling */
9327                  159,           /* Minimum in-band energy threshold */
9328                  21,            /* 21/32 in-band to broad-band ratio */
9329                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9330         },
9331         {                       /* f400_450[] */
9332                 30613,          /* A1 = 1.86853 */
9333                  -32031,        /* A2 = -0.977509 */
9334                  -618,          /* B2 = -0.018866 */
9335                  0,             /* B1 = 0 */
9336                  618,           /* B0 = 0.018866 */
9337                  30577,         /* A1 = 1.866272 */
9338                  -32491,        /* A2 = -0.991577 */
9339                  9612,          /* B2 = 0.293335 */
9340                  -8935,         /* B1 = -0.54541 */
9341                  9612,          /* B0 = 0.293335 */
9342                  31071,         /* A1 = 1.896484 */
9343                  -32524,        /* A2 = -0.992584 */
9344                  21596,         /* B2 = 0.659058 */
9345                  -20667,        /* B1 = -1.261414 */
9346                  21596,         /* B0 = 0.659058 */
9347                  7,             /* Internal filter scaling */
9348                  159,           /* Minimum in-band energy threshold */
9349                  21,            /* 21/32 in-band to broad-band ratio */
9350                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9351         },
9352         {                       /* f420 */
9353                 30914,          /* A1 = -1.886841 */
9354                  -32584,        /* A2 = 0.994385 */
9355                  -426,          /* B2 = -0.013020 */
9356                  0,             /* B1 = 0.000000 */
9357                  426,           /* B0 = 0.013020 */
9358                  30914,         /* A1 = -1.886841 */
9359                  -32679,        /* A2 = 0.997314 */
9360                  17520,         /* B2 = 0.534668 */
9361                  -16471,        /* B1 = -1.005310 */
9362                  17520,         /* B0 = 0.534668 */
9363                  31004,         /* A1 = -1.892334 */
9364                  -32683,        /* A2 = 0.997406 */
9365                  819,           /* B2 = 0.025023 */
9366                  -780,          /* B1 = -0.047619 */
9367                  819,           /* B0 = 0.025023 */
9368                  5,             /* Internal filter scaling */
9369                  159,           /* Minimum in-band energy threshold */
9370                  21,            /* 21/32 in-band to broad-band ratio */
9371                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9372         },
9373 #if 0
9374         {                       /* f425 */
9375                 30881,          /* A1 = -1.884827 */
9376                  -32603,        /* A2 = 0.994965 */
9377                  -496,          /* B2 = -0.015144 */
9378                  0,             /* B1 = 0.000000 */
9379                  496,           /* B0 = 0.015144 */
9380                  30880,         /* A1 = -1.884766 */
9381                  -32692,        /* A2 = 0.997711 */
9382                  24767,         /* B2 = 0.755859 */
9383                  -23290,        /* B1 = -1.421509 */
9384                  24767,         /* B0 = 0.755859 */
9385                  30967,         /* A1 = -1.890076 */
9386                  -32694,        /* A2 = 0.997772 */
9387                  728,           /* B2 = 0.022232 */
9388                  -691,          /* B1 = -0.042194 */
9389                  728,           /* B0 = 0.022232 */
9390                  5,             /* Internal filter scaling */
9391                  159,           /* Minimum in-band energy threshold */
9392                  21,            /* 21/32 in-band to broad-band ratio */
9393                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394         },
9395 #else
9396         {
9397                 30850,
9398                 -32534,
9399                 -504,
9400                 0,
9401                 504,
9402                 30831,
9403                 -32669,
9404                 24303,
9405                 -22080,
9406                 24303,
9407                 30994,
9408                 -32673,
9409                 1905,
9410                 -1811,
9411                 1905,
9412                 5,
9413                 129,
9414                 17,
9415                 0xff5
9416         },
9417 #endif
9418         {                       /* f425_450[] */
9419                 30646,          /* A1 = 1.870544 */
9420                  -32327,        /* A2 = -0.986572 */
9421                  -287,          /* B2 = -0.008769 */
9422                  0,             /* B1 = 0 */
9423                  287,           /* B0 = 0.008769 */
9424                  30627,         /* A1 = 1.869324 */
9425                  -32607,        /* A2 = -0.995087 */
9426                  13269,         /* B2 = 0.404968 */
9427                  -12376,        /* B1 = -0.755432 */
9428                  13269,         /* B0 = 0.404968 */
9429                  30924,         /* A1 = 1.887512 */
9430                  -32619,        /* A2 = -0.995453 */
9431                  19950,         /* B2 = 0.608826 */
9432                  -18940,        /* B1 = -1.156006 */
9433                  19950,         /* B0 = 0.608826 */
9434                  7,             /* Internal filter scaling */
9435                  159,           /* Minimum in-band energy threshold */
9436                  21,            /* 21/32 in-band to broad-band ratio */
9437                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9438         },
9439         {                       /* f425_475[] */
9440                 30396,          /* A1 = 1.855225 */
9441                  -32014,        /* A2 = -0.97699 */
9442                  -395,          /* B2 = -0.012055 */
9443                  0,             /* B1 = 0 */
9444                  395,           /* B0 = 0.012055 */
9445                  30343,         /* A1 = 1.85199 */
9446                  -32482,        /* A2 = -0.991302 */
9447                  17823,         /* B2 = 0.543945 */
9448                  -16431,        /* B1 = -1.002869 */
9449                  17823,         /* B0 = 0.543945 */
9450                  30872,         /* A1 = 1.884338 */
9451                  -32516,        /* A2 = -0.99231 */
9452                  18124,         /* B2 = 0.553101 */
9453                  -17246,        /* B1 = -1.052673 */
9454                  18124,         /* B0 = 0.553101 */
9455                  7,             /* Internal filter scaling */
9456                  159,           /* Minimum in-band energy threshold */
9457                  21,            /* 21/32 in-band to broad-band ratio */
9458                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9459         },
9460         {                       /* f435 */
9461                 30796,          /* A1 = -1.879639 */
9462                  -32603,        /* A2 = 0.994965 */
9463                  -254,          /* B2 = -0.007762 */
9464                  0,             /* B1 = 0.000000 */
9465                  254,           /* B0 = 0.007762 */
9466                  30793,         /* A1 = -1.879456 */
9467                  -32692,        /* A2 = 0.997711 */
9468                  18934,         /* B2 = 0.577820 */
9469                  -17751,        /* B1 = -1.083496 */
9470                  18934,         /* B0 = 0.577820 */
9471                  30882,         /* A1 = -1.884888 */
9472                  -32694,        /* A2 = 0.997772 */
9473                  1858,          /* B2 = 0.056713 */
9474                  -1758,         /* B1 = -0.107357 */
9475                  1858,          /* B0 = 0.056713 */
9476                  5,             /* Internal filter scaling */
9477                  159,           /* Minimum in-band energy threshold */
9478                  21,            /* 21/32 in-band to broad-band ratio */
9479                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9480         },
9481         {                       /* f440_450[] */
9482                 30641,          /* A1 = 1.870239 */
9483                  -32458,        /* A2 = -0.99057 */
9484                  -155,          /* B2 = -0.004735 */
9485                  0,             /* B1 = 0 */
9486                  155,           /* B0 = 0.004735 */
9487                  30631,         /* A1 = 1.869568 */
9488                  -32630,        /* A2 = -0.995789 */
9489                  11453,         /* B2 = 0.349548 */
9490                  -10666,        /* B1 = -0.651001 */
9491                  11453,         /* B0 = 0.349548 */
9492                  30810,         /* A1 = 1.880554 */
9493                  -32634,        /* A2 = -0.995941 */
9494                  12237,         /* B2 = 0.373474 */
9495                  -11588,        /* B1 = -0.707336 */
9496                  12237,         /* B0 = 0.373474 */
9497                  7,             /* Internal filter scaling */
9498                  159,           /* Minimum in-band energy threshold */
9499                  21,            /* 21/32 in-band to broad-band ratio */
9500                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9501         },
9502         {                       /* f440_480[] */
9503                 30367,          /* A1 = 1.853455 */
9504                  -32147,        /* A2 = -0.981079 */
9505                  -495,          /* B2 = -0.015113 */
9506                  0,             /* B1 = 0 */
9507                  495,           /* B0 = 0.015113 */
9508                  30322,         /* A1 = 1.850769 */
9509                  -32543,        /* A2 = -0.993134 */
9510                  10031,         /* B2 = 0.306152 */
9511                  -9252,         /* B1 = -0.564728 */
9512                  10031,         /* B0 = 0.306152 */
9513                  30770,         /* A1 = 1.878052 */
9514                  -32563,        /* A2 = -0.993774 */
9515                  22674,         /* B2 = 0.691956 */
9516                  -21465,        /* B1 = -1.31012 */
9517                  22674,         /* B0 = 0.691956 */
9518                  7,             /* Internal filter scaling */
9519                  159,           /* Minimum in-band energy threshold */
9520                  21,            /* 21/32 in-band to broad-band ratio */
9521                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9522         },
9523         {                       /* f445 */
9524                 30709,          /* A1 = -1.874329 */
9525                  -32603,        /* A2 = 0.994965 */
9526                  -83,           /* B2 = -0.002545 */
9527                  0,             /* B1 = 0.000000 */
9528                  83,            /* B0 = 0.002545 */
9529                  30704,         /* A1 = -1.874084 */
9530                  -32692,        /* A2 = 0.997711 */
9531                  10641,         /* B2 = 0.324738 */
9532                  -9947,         /* B1 = -0.607147 */
9533                  10641,         /* B0 = 0.324738 */
9534                  30796,         /* A1 = -1.879639 */
9535                  -32694,        /* A2 = 0.997772 */
9536                  10079,         /* B2 = 0.307587 */
9537                  9513,          /* B1 = 0.580688 */
9538                  10079,         /* B0 = 0.307587 */
9539                  5,             /* Internal filter scaling */
9540                  159,           /* Minimum in-band energy threshold */
9541                  21,            /* 21/32 in-band to broad-band ratio */
9542                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9543         },
9544         {                       /* f450 */
9545                 30664,          /* A1 = -1.871643 */
9546                  -32603,        /* A2 = 0.994965 */
9547                  -164,          /* B2 = -0.005029 */
9548                  0,             /* B1 = 0.000000 */
9549                  164,           /* B0 = 0.005029 */
9550                  30661,         /* A1 = -1.871399 */
9551                  -32692,        /* A2 = 0.997711 */
9552                  15294,         /* B2 = 0.466736 */
9553                  -14275,        /* B1 = -0.871307 */
9554                  15294,         /* B0 = 0.466736 */
9555                  30751,         /* A1 = -1.876953 */
9556                  -32694,        /* A2 = 0.997772 */
9557                  3548,          /* B2 = 0.108284 */
9558                  -3344,         /* B1 = -0.204155 */
9559                  3548,          /* B0 = 0.108284 */
9560                  5,             /* Internal filter scaling */
9561                  159,           /* Minimum in-band energy threshold */
9562                  21,            /* 21/32 in-band to broad-band ratio */
9563                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9564         },
9565         {                       /* f452 */
9566                 30653,          /* A1 = -1.870911 */
9567                  -32615,        /* A2 = 0.995361 */
9568                  -209,          /* B2 = -0.006382 */
9569                  0,             /* B1 = 0.000000 */
9570                  209,           /* B0 = 0.006382 */
9571                  30647,         /* A1 = -1.870605 */
9572                  -32702,        /* A2 = 0.997986 */
9573                  18971,         /* B2 = 0.578979 */
9574                  -17716,        /* B1 = -1.081299 */
9575                  18971,         /* B0 = 0.578979 */
9576                  30738,         /* A1 = -1.876099 */
9577                  -32702,        /* A2 = 0.998016 */
9578                  2967,          /* B2 = 0.090561 */
9579                  -2793,         /* B1 = -0.170502 */
9580                  2967,          /* B0 = 0.090561 */
9581                  5,             /* Internal filter scaling */
9582                  159,           /* Minimum in-band energy threshold */
9583                  21,            /* 21/32 in-band to broad-band ratio */
9584                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9585         },
9586         {                       /* f475 */
9587                 30437,          /* A1 = -1.857727 */
9588                  -32603,        /* A2 = 0.994965 */
9589                  -264,          /* B2 = -0.008062 */
9590                  0,             /* B1 = 0.000000 */
9591                  264,           /* B0 = 0.008062 */
9592                  30430,         /* A1 = -1.857300 */
9593                  -32692,        /* A2 = 0.997711 */
9594                  21681,         /* B2 = 0.661682 */
9595                  -20082,        /* B1 = -1.225708 */
9596                  21681,         /* B0 = 0.661682 */
9597                  30526,         /* A1 = -1.863220 */
9598                  -32694,        /* A2 = 0.997742 */
9599                  1559,          /* B2 = 0.047600 */
9600                  -1459,         /* B1 = -0.089096 */
9601                  1559,          /* B0 = 0.047600 */
9602                  5,             /* Internal filter scaling */
9603                  159,           /* Minimum in-band energy threshold */
9604                  21,            /* 21/32 in-band to broad-band ratio */
9605                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9606         },
9607         {                       /* f480_620[] */
9608                 28975,          /* A1 = 1.768494 */
9609                  -30955,        /* A2 = -0.944672 */
9610                  -1026,         /* B2 = -0.03133 */
9611                  0,             /* B1 = 0 */
9612                  1026,          /* B0 = 0.03133 */
9613                  28613,         /* A1 = 1.746399 */
9614                  -32089,        /* A2 = -0.979309 */
9615                  14214,         /* B2 = 0.433807 */
9616                  -12202,        /* B1 = -0.744812 */
9617                  14214,         /* B0 = 0.433807 */
9618                  30243,         /* A1 = 1.845947 */
9619                  -32238,        /* A2 = -0.983856 */
9620                  24825,         /* B2 = 0.757629 */
9621                  -23402,        /* B1 = -1.428345 */
9622                  24825,         /* B0 = 0.757629 */
9623                  7,             /* Internal filter scaling */
9624                  159,           /* Minimum in-band energy threshold */
9625                  21,            /* 21/32 in-band to broad-band ratio */
9626                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9627         },
9628         {                       /* f494 */
9629                 30257,          /* A1 = -1.846741 */
9630                  -32605,        /* A2 = 0.995056 */
9631                  -249,          /* B2 = -0.007625 */
9632                  0,             /* B1 = 0.000000 */
9633                  249,           /* B0 = 0.007625 */
9634                  30247,         /* A1 = -1.846191 */
9635                  -32694,        /* A2 = 0.997772 */
9636                  18088,         /* B2 = 0.552002 */
9637                  -16652,        /* B1 = -1.016418 */
9638                  18088,         /* B0 = 0.552002 */
9639                  30348,         /* A1 = -1.852295 */
9640                  -32696,        /* A2 = 0.997803 */
9641                  2099,          /* B2 = 0.064064 */
9642                  -1953,         /* B1 = -0.119202 */
9643                  2099,          /* B0 = 0.064064 */
9644                  5,             /* Internal filter scaling */
9645                  159,           /* Minimum in-band energy threshold */
9646                  21,            /* 21/32 in-band to broad-band ratio */
9647                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9648         },
9649         {                       /* f500 */
9650                 30202,          /* A1 = -1.843431 */
9651                  -32624,        /* A2 = 0.995622 */
9652                  -413,          /* B2 = -0.012622 */
9653                  0,             /* B1 = 0.000000 */
9654                  413,           /* B0 = 0.012622 */
9655                  30191,         /* A1 = -1.842721 */
9656                  -32714,        /* A2 = 0.998364 */
9657                  25954,         /* B2 = 0.792057 */
9658                  -23890,        /* B1 = -1.458131 */
9659                  25954,         /* B0 = 0.792057 */
9660                  30296,         /* A1 = -1.849172 */
9661                  -32715,        /* A2 = 0.998397 */
9662                  2007,          /* B2 = 0.061264 */
9663                  -1860,         /* B1 = -0.113568 */
9664                  2007,          /* B0 = 0.061264 */
9665                  5,             /* Internal filter scaling */
9666                  159,           /* Minimum in-band energy threshold */
9667                  21,            /* 21/32 in-band to broad-band ratio */
9668                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9669         },
9670         {                       /* f520 */
9671                 30001,          /* A1 = -1.831116 */
9672                  -32613,        /* A2 = 0.995270 */
9673                  -155,          /* B2 = -0.004750 */
9674                  0,             /* B1 = 0.000000 */
9675                  155,           /* B0 = 0.004750 */
9676                  29985,         /* A1 = -1.830200 */
9677                  -32710,        /* A2 = 0.998260 */
9678                  6584,          /* B2 = 0.200928 */
9679                  -6018,         /* B1 = -0.367355 */
9680                  6584,          /* B0 = 0.200928 */
9681                  30105,         /* A1 = -1.837524 */
9682                  -32712,        /* A2 = 0.998291 */
9683                  23812,         /* B2 = 0.726685 */
9684                  -21936,        /* B1 = -1.338928 */
9685                  23812,         /* B0 = 0.726685 */
9686                  5,             /* Internal filter scaling */
9687                  159,           /* Minimum in-band energy threshold */
9688                  21,            /* 21/32 in-band to broad-band ratio */
9689                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9690         },
9691         {                       /* f523 */
9692                 29964,          /* A1 = -1.828918 */
9693                  -32601,        /* A2 = 0.994904 */
9694                  -101,          /* B2 = -0.003110 */
9695                  0,             /* B1 = 0.000000 */
9696                  101,           /* B0 = 0.003110 */
9697                  29949,         /* A1 = -1.827942 */
9698                  -32700,        /* A2 = 0.997925 */
9699                  11041,         /* B2 = 0.336975 */
9700                  -10075,        /* B1 = -0.614960 */
9701                  11041,         /* B0 = 0.336975 */
9702                  30070,         /* A1 = -1.835388 */
9703                  -32702,        /* A2 = 0.997986 */
9704                  16762,         /* B2 = 0.511536 */
9705                  -15437,        /* B1 = -0.942230 */
9706                  16762,         /* B0 = 0.511536 */
9707                  5,             /* Internal filter scaling */
9708                  159,           /* Minimum in-band energy threshold */
9709                  21,            /* 21/32 in-band to broad-band ratio */
9710                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9711         },
9712         {                       /* f525 */
9713                 29936,          /* A1 = -1.827209 */
9714                  -32584,        /* A2 = 0.994415 */
9715                  -91,           /* B2 = -0.002806 */
9716                  0,             /* B1 = 0.000000 */
9717                  91,            /* B0 = 0.002806 */
9718                  29921,         /* A1 = -1.826233 */
9719                  -32688,        /* A2 = 0.997559 */
9720                  11449,         /* B2 = 0.349396 */
9721                  -10426,        /* B1 = -0.636383 */
9722                  11449,         /* B0 = 0.349396 */
9723                  30045,         /* A1 = -1.833862 */
9724                  -32688,        /* A2 = 0.997589 */
9725                  13055,         /* B2 = 0.398407 */
9726                  -12028,        /* B1 = -0.734161 */
9727                  13055,         /* B0 = 0.398407 */
9728                  5,             /* Internal filter scaling */
9729                  159,           /* Minimum in-band energy threshold */
9730                  21,            /* 21/32 in-band to broad-band ratio */
9731                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9732         },
9733         {                       /* f540_660[] */
9734                 28499,          /* A1 = 1.739441 */
9735                  -31129,        /* A2 = -0.949982 */
9736                  -849,          /* B2 = -0.025922 */
9737                  0,             /* B1 = 0 */
9738                  849,           /* B0 = 0.025922 */
9739                  28128,         /* A1 = 1.716797 */
9740                  -32130,        /* A2 = -0.98056 */
9741                  14556,         /* B2 = 0.444214 */
9742                  -12251,        /* B1 = -0.747772 */
9743                  14556,         /* B0 = 0.444244 */
9744                  29667,         /* A1 = 1.81073 */
9745                  -32244,        /* A2 = -0.984039 */
9746                  23038,         /* B2 = 0.703064 */
9747                  -21358,        /* B1 = -1.303589 */
9748                  23040,         /* B0 = 0.703125 */
9749                  7,             /* Internal filter scaling */
9750                  159,           /* Minimum in-band energy threshold */
9751                  21,            /* 21/32 in-band to broad-band ratio */
9752                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9753         },
9754         {                       /* f587 */
9755                 29271,          /* A1 = -1.786560 */
9756                  -32599,        /* A2 = 0.994873 */
9757                  -490,          /* B2 = -0.014957 */
9758                  0,             /* B1 = 0.000000 */
9759                  490,           /* B0 = 0.014957 */
9760                  29246,         /* A1 = -1.785095 */
9761                  -32700,        /* A2 = 0.997925 */
9762                  28961,         /* B2 = 0.883850 */
9763                  -25796,        /* B1 = -1.574463 */
9764                  28961,         /* B0 = 0.883850 */
9765                  29383,         /* A1 = -1.793396 */
9766                  -32700,        /* A2 = 0.997955 */
9767                  1299,          /* B2 = 0.039650 */
9768                  -1169,         /* B1 = -0.071396 */
9769                  1299,          /* B0 = 0.039650 */
9770                  5,             /* Internal filter scaling */
9771                  159,           /* Minimum in-band energy threshold */
9772                  21,            /* 21/32 in-band to broad-band ratio */
9773                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9774         },
9775         {                       /* f590 */
9776                 29230,          /* A1 = -1.784058 */
9777                  -32584,        /* A2 = 0.994415 */
9778                  -418,          /* B2 = -0.012757 */
9779                  0,             /* B1 = 0.000000 */
9780                  418,           /* B0 = 0.012757 */
9781                  29206,         /* A1 = -1.782593 */
9782                  -32688,        /* A2 = 0.997559 */
9783                  36556,         /* B2 = 1.115601 */
9784                  -32478,        /* B1 = -1.982300 */
9785                  36556,         /* B0 = 1.115601 */
9786                  29345,         /* A1 = -1.791077 */
9787                  -32688,        /* A2 = 0.997589 */
9788                  897,           /* B2 = 0.027397 */
9789                  -808,          /* B1 = -0.049334 */
9790                  897,           /* B0 = 0.027397 */
9791                  5,             /* Internal filter scaling */
9792                  159,           /* Minimum in-band energy threshold */
9793                  21,            /* 21/32 in-band to broad-band ratio */
9794                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9795         },
9796         {                       /* f600 */
9797                 29116,          /* A1 = -1.777100 */
9798                  -32603,        /* A2 = 0.994965 */
9799                  -165,          /* B2 = -0.005039 */
9800                  0,             /* B1 = 0.000000 */
9801                  165,           /* B0 = 0.005039 */
9802                  29089,         /* A1 = -1.775452 */
9803                  -32708,        /* A2 = 0.998199 */
9804                  6963,          /* B2 = 0.212494 */
9805                  -6172,         /* B1 = -0.376770 */
9806                  6963,          /* B0 = 0.212494 */
9807                  29237,         /* A1 = -1.784485 */
9808                  -32710,        /* A2 = 0.998230 */
9809                  24197,         /* B2 = 0.738464 */
9810                  -21657,        /* B1 = -1.321899 */
9811                  24197,         /* B0 = 0.738464 */
9812                  5,             /* Internal filter scaling */
9813                  159,           /* Minimum in-band energy threshold */
9814                  21,            /* 21/32 in-band to broad-band ratio */
9815                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9816         },
9817         {                       /* f660 */
9818                 28376,          /* A1 = -1.731934 */
9819                  -32567,        /* A2 = 0.993896 */
9820                  -363,          /* B2 = -0.011102 */
9821                  0,             /* B1 = 0.000000 */
9822                  363,           /* B0 = 0.011102 */
9823                  28337,         /* A1 = -1.729614 */
9824                  -32683,        /* A2 = 0.997434 */
9825                  21766,         /* B2 = 0.664246 */
9826                  -18761,        /* B1 = -1.145081 */
9827                  21766,         /* B0 = 0.664246 */
9828                  28513,         /* A1 = -1.740356 */
9829                  -32686,        /* A2 = 0.997498 */
9830                  2509,          /* B2 = 0.076584 */
9831                  -2196,         /* B1 = -0.134041 */
9832                  2509,          /* B0 = 0.076584 */
9833                  5,             /* Internal filter scaling */
9834                  159,           /* Minimum in-band energy threshold */
9835                  21,            /* 21/32 in-band to broad-band ratio */
9836                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9837         },
9838         {                       /* f700 */
9839                 27844,          /* A1 = -1.699463 */
9840                  -32563,        /* A2 = 0.993744 */
9841                  -366,          /* B2 = -0.011187 */
9842                  0,             /* B1 = 0.000000 */
9843                  366,           /* B0 = 0.011187 */
9844                  27797,         /* A1 = -1.696655 */
9845                  -32686,        /* A2 = 0.997498 */
9846                  22748,         /* B2 = 0.694214 */
9847                  -19235,        /* B1 = -1.174072 */
9848                  22748,         /* B0 = 0.694214 */
9849                  27995,         /* A1 = -1.708740 */
9850                  -32688,        /* A2 = 0.997559 */
9851                  2964,          /* B2 = 0.090477 */
9852                  -2546,         /* B1 = -0.155449 */
9853                  2964,          /* B0 = 0.090477 */
9854                  5,             /* Internal filter scaling */
9855                  159,           /* Minimum in-band energy threshold */
9856                  21,            /* 21/32 in-band to broad-band ratio */
9857                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9858         },
9859         {                       /* f740 */
9860                 27297,          /* A1 = -1.666077 */
9861                  -32551,        /* A2 = 0.993408 */
9862                  -345,          /* B2 = -0.010540 */
9863                  0,             /* B1 = 0.000000 */
9864                  345,           /* B0 = 0.010540 */
9865                  27240,         /* A1 = -1.662598 */
9866                  -32683,        /* A2 = 0.997406 */
9867                  22560,         /* B2 = 0.688477 */
9868                  -18688,        /* B1 = -1.140625 */
9869                  22560,         /* B0 = 0.688477 */
9870                  27461,         /* A1 = -1.676147 */
9871                  -32684,        /* A2 = 0.997467 */
9872                  3541,          /* B2 = 0.108086 */
9873                  -2985,         /* B1 = -0.182220 */
9874                  3541,          /* B0 = 0.108086 */
9875                  5,             /* Internal filter scaling */
9876                  159,           /* Minimum in-band energy threshold */
9877                  21,            /* 21/32 in-band to broad-band ratio */
9878                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9879         },
9880         {                       /* f750 */
9881                 27155,          /* A1 = -1.657410 */
9882                  -32551,        /* A2 = 0.993408 */
9883                  -462,          /* B2 = -0.014117 */
9884                  0,             /* B1 = 0.000000 */
9885                  462,           /* B0 = 0.014117 */
9886                  27097,         /* A1 = -1.653870 */
9887                  -32683,        /* A2 = 0.997406 */
9888                  32495,         /* B2 = 0.991699 */
9889                  -26776,        /* B1 = -1.634338 */
9890                  32495,         /* B0 = 0.991699 */
9891                  27321,         /* A1 = -1.667542 */
9892                  -32684,        /* A2 = 0.997467 */
9893                  1835,          /* B2 = 0.056007 */
9894                  -1539,         /* B1 = -0.093948 */
9895                  1835,          /* B0 = 0.056007 */
9896                  5,             /* Internal filter scaling */
9897                  159,           /* Minimum in-band energy threshold */
9898                  21,            /* 21/32 in-band to broad-band ratio */
9899                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9900         },
9901         {                       /* f750_1450[] */
9902                 19298,          /* A1 = 1.177917 */
9903                  -24471,        /* A2 = -0.746796 */
9904                  -4152,         /* B2 = -0.126709 */
9905                  0,             /* B1 = 0 */
9906                  4152,          /* B0 = 0.126709 */
9907                  12902,         /* A1 = 0.787476 */
9908                  -29091,        /* A2 = -0.887817 */
9909                  12491,         /* B2 = 0.38121 */
9910                  -1794,         /* B1 = -0.109528 */
9911                  12494,         /* B0 = 0.381317 */
9912                  26291,         /* A1 = 1.604736 */
9913                  -30470,        /* A2 = -0.929901 */
9914                  28859,         /* B2 = 0.880737 */
9915                  -26084,        /* B1 = -1.592102 */
9916                  28861,         /* B0 = 0.880798 */
9917                  7,             /* Internal filter scaling */
9918                  159,           /* Minimum in-band energy threshold */
9919                  21,            /* 21/32 in-band to broad-band ratio */
9920                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9921         },
9922         {                       /* f770 */
9923                 26867,          /* A1 = -1.639832 */
9924                  -32551,        /* A2 = 0.993408 */
9925                  -123,          /* B2 = -0.003755 */
9926                  0,             /* B1 = 0.000000 */
9927                  123,           /* B0 = 0.003755 */
9928                  26805,         /* A1 = -1.636108 */
9929                  -32683,        /* A2 = 0.997406 */
9930                  17297,         /* B2 = 0.527863 */
9931                  -14096,        /* B1 = -0.860382 */
9932                  17297,         /* B0 = 0.527863 */
9933                  27034,         /* A1 = -1.650085 */
9934                  -32684,        /* A2 = 0.997467 */
9935                  12958,         /* B2 = 0.395477 */
9936                  -10756,        /* B1 = -0.656525 */
9937                  12958,         /* B0 = 0.395477 */
9938                  5,             /* Internal filter scaling */
9939                  159,           /* Minimum in-band energy threshold */
9940                  21,            /* 21/32 in-band to broad-band ratio */
9941                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9942         },
9943         {                       /* f800 */
9944                 26413,          /* A1 = -1.612122 */
9945                  -32547,        /* A2 = 0.993286 */
9946                  -223,          /* B2 = -0.006825 */
9947                  0,             /* B1 = 0.000000 */
9948                  223,           /* B0 = 0.006825 */
9949                  26342,         /* A1 = -1.607849 */
9950                  -32686,        /* A2 = 0.997498 */
9951                  6391,          /* B2 = 0.195053 */
9952                  -5120,         /* B1 = -0.312531 */
9953                  6391,          /* B0 = 0.195053 */
9954                  26593,         /* A1 = -1.623108 */
9955                  -32688,        /* A2 = 0.997559 */
9956                  23681,         /* B2 = 0.722717 */
9957                  -19328,        /* B1 = -1.179688 */
9958                  23681,         /* B0 = 0.722717 */
9959                  5,             /* Internal filter scaling */
9960                  159,           /* Minimum in-band energy threshold */
9961                  21,            /* 21/32 in-band to broad-band ratio */
9962                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9963         },
9964         {                       /* f816 */
9965                 26168,          /* A1 = -1.597209 */
9966                  -32528,        /* A2 = 0.992706 */
9967                  -235,          /* B2 = -0.007182 */
9968                  0,             /* B1 = 0.000000 */
9969                  235,           /* B0 = 0.007182 */
9970                  26092,         /* A1 = -1.592590 */
9971                  -32675,        /* A2 = 0.997192 */
9972                  20823,         /* B2 = 0.635498 */
9973                  -16510,        /* B1 = -1.007751 */
9974                  20823,         /* B0 = 0.635498 */
9975                  26363,         /* A1 = -1.609070 */
9976                  -32677,        /* A2 = 0.997253 */
9977                  6739,          /* B2 = 0.205688 */
9978                  -5459,         /* B1 = -0.333206 */
9979                  6739,          /* B0 = 0.205688 */
9980                  5,             /* Internal filter scaling */
9981                  159,           /* Minimum in-band energy threshold */
9982                  21,            /* 21/32 in-band to broad-band ratio */
9983                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9984         },
9985         {                       /* f850 */
9986                 25641,          /* A1 = -1.565063 */
9987                  -32536,        /* A2 = 0.992950 */
9988                  -121,          /* B2 = -0.003707 */
9989                  0,             /* B1 = 0.000000 */
9990                  121,           /* B0 = 0.003707 */
9991                  25560,         /* A1 = -1.560059 */
9992                  -32684,        /* A2 = 0.997437 */
9993                  18341,         /* B2 = 0.559753 */
9994                  -14252,        /* B1 = -0.869904 */
9995                  18341,         /* B0 = 0.559753 */
9996                  25837,         /* A1 = -1.577026 */
9997                  -32684,        /* A2 = 0.997467 */
9998                  16679,         /* B2 = 0.509003 */
9999                  -13232,        /* B1 = -0.807648 */
10000                  16679,         /* B0 = 0.509003 */
10001                  5,             /* Internal filter scaling */
10002                  159,           /* Minimum in-band energy threshold */
10003                  21,            /* 21/32 in-band to broad-band ratio */
10004                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10005         },
10006         {                       /* f857_1645[] */
10007                 16415,          /* A1 = 1.001953 */
10008                  -23669,        /* A2 = -0.722321 */
10009                  -4549,         /* B2 = -0.138847 */
10010                  0,             /* B1 = 0 */
10011                  4549,          /* B0 = 0.138847 */
10012                  8456,          /* A1 = 0.516174 */
10013                  -28996,        /* A2 = -0.884918 */
10014                  13753,         /* B2 = 0.419724 */
10015                  -12,           /* B1 = -0.000763 */
10016                  13757,         /* B0 = 0.419846 */
10017                  24632,         /* A1 = 1.503418 */
10018                  -30271,        /* A2 = -0.923828 */
10019                  29070,         /* B2 = 0.887146 */
10020                  -25265,        /* B1 = -1.542114 */
10021                  29073,         /* B0 = 0.887268 */
10022                  7,             /* Internal filter scaling */
10023                  159,           /* Minimum in-band energy threshold */
10024                  21,            /* 21/32 in-band to broad-band ratio */
10025                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10026         },
10027         {                       /* f900 */
10028                 24806,          /* A1 = -1.514099 */
10029                  -32501,        /* A2 = 0.991852 */
10030                  -326,          /* B2 = -0.009969 */
10031                  0,             /* B1 = 0.000000 */
10032                  326,           /* B0 = 0.009969 */
10033                  24709,         /* A1 = -1.508118 */
10034                  -32659,        /* A2 = 0.996674 */
10035                  20277,         /* B2 = 0.618835 */
10036                  -15182,        /* B1 = -0.926636 */
10037                  20277,         /* B0 = 0.618835 */
10038                  25022,         /* A1 = -1.527222 */
10039                  -32661,        /* A2 = 0.996735 */
10040                  4320,          /* B2 = 0.131836 */
10041                  -3331,         /* B1 = -0.203339 */
10042                  4320,          /* B0 = 0.131836 */
10043                  5,             /* Internal filter scaling */
10044                  159,           /* Minimum in-band energy threshold */
10045                  21,            /* 21/32 in-band to broad-band ratio */
10046                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10047         },
10048         {                       /* f900_1300[] */
10049                 19776,          /* A1 = 1.207092 */
10050                  -27437,        /* A2 = -0.837341 */
10051                  -2666,         /* B2 = -0.081371 */
10052                  0,             /* B1 = 0 */
10053                  2666,          /* B0 = 0.081371 */
10054                  16302,         /* A1 = 0.995026 */
10055                  -30354,        /* A2 = -0.926361 */
10056                  10389,         /* B2 = 0.317062 */
10057                  -3327,         /* B1 = -0.203064 */
10058                  10389,         /* B0 = 0.317062 */
10059                  24299,         /* A1 = 1.483154 */
10060                  -30930,        /* A2 = -0.943909 */
10061                  25016,         /* B2 = 0.763428 */
10062                  -21171,        /* B1 = -1.292236 */
10063                  25016,         /* B0 = 0.763428 */
10064                  7,             /* Internal filter scaling */
10065                  159,           /* Minimum in-band energy threshold */
10066                  21,            /* 21/32 in-band to broad-band ratio */
10067                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10068         },
10069         {                       /* f935_1215[] */
10070                 20554,          /* A1 = 1.254517 */
10071                  -28764,        /* A2 = -0.877838 */
10072                  -2048,         /* B2 = -0.062515 */
10073                  0,             /* B1 = 0 */
10074                  2048,          /* B0 = 0.062515 */
10075                  18209,         /* A1 = 1.11145 */
10076                  -30951,        /* A2 = -0.94458 */
10077                  9390,          /* B2 = 0.286575 */
10078                  -3955,         /* B1 = -0.241455 */
10079                  9390,          /* B0 = 0.286575 */
10080                  23902,         /* A1 = 1.458923 */
10081                  -31286,        /* A2 = -0.954803 */
10082                  23252,         /* B2 = 0.709595 */
10083                  -19132,        /* B1 = -1.167725 */
10084                  23252,         /* B0 = 0.709595 */
10085                  7,             /* Internal filter scaling */
10086                  159,           /* Minimum in-band energy threshold */
10087                  21,            /* 21/32 in-band to broad-band ratio */
10088                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10089         },
10090         {                       /* f941_1477[] */
10091                 17543,          /* A1 = 1.07074 */
10092                  -26220,        /* A2 = -0.800201 */
10093                  -3298,         /* B2 = -0.100647 */
10094                  0,             /* B1 = 0 */
10095                  3298,          /* B0 = 0.100647 */
10096                  12423,         /* A1 = 0.75827 */
10097                  -30036,        /* A2 = -0.916626 */
10098                  12651,         /* B2 = 0.386078 */
10099                  -2444,         /* B1 = -0.14917 */
10100                  12653,         /* B0 = 0.386154 */
10101                  23518,         /* A1 = 1.435425 */
10102                  -30745,        /* A2 = -0.938293 */
10103                  27282,         /* B2 = 0.832581 */
10104                  -22529,        /* B1 = -1.375122 */
10105                  27286,         /* B0 = 0.832703 */
10106                  7,             /* Internal filter scaling */
10107                  159,           /* Minimum in-band energy threshold */
10108                  21,            /* 21/32 in-band to broad-band ratio */
10109                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10110         },
10111         {                       /* f942 */
10112                 24104,          /* A1 = -1.471252 */
10113                  -32507,        /* A2 = 0.992065 */
10114                  -351,          /* B2 = -0.010722 */
10115                  0,             /* B1 = 0.000000 */
10116                  351,           /* B0 = 0.010722 */
10117                  23996,         /* A1 = -1.464600 */
10118                  -32671,        /* A2 = 0.997040 */
10119                  22848,         /* B2 = 0.697266 */
10120                  -16639,        /* B1 = -1.015564 */
10121                  22848,         /* B0 = 0.697266 */
10122                  24332,         /* A1 = -1.485168 */
10123                  -32673,        /* A2 = 0.997101 */
10124                  4906,          /* B2 = 0.149727 */
10125                  -3672,         /* B1 = -0.224174 */
10126                  4906,          /* B0 = 0.149727 */
10127                  5,             /* Internal filter scaling */
10128                  159,           /* Minimum in-band energy threshold */
10129                  21,            /* 21/32 in-band to broad-band ratio */
10130                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10131         },
10132         {                       /* f950 */
10133                 23967,          /* A1 = -1.462830 */
10134                  -32507,        /* A2 = 0.992065 */
10135                  -518,          /* B2 = -0.015821 */
10136                  0,             /* B1 = 0.000000 */
10137                  518,           /* B0 = 0.015821 */
10138                  23856,         /* A1 = -1.456055 */
10139                  -32671,        /* A2 = 0.997040 */
10140                  26287,         /* B2 = 0.802246 */
10141                  -19031,        /* B1 = -1.161560 */
10142                  26287,         /* B0 = 0.802246 */
10143                  24195,         /* A1 = -1.476746 */
10144                  -32673,        /* A2 = 0.997101 */
10145                  2890,          /* B2 = 0.088196 */
10146                  -2151,         /* B1 = -0.131317 */
10147                  2890,          /* B0 = 0.088196 */
10148                  5,             /* Internal filter scaling */
10149                  159,           /* Minimum in-band energy threshold */
10150                  21,            /* 21/32 in-band to broad-band ratio */
10151                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10152         },
10153         {                       /* f950_1400[] */
10154                 18294,          /* A1 = 1.116638 */
10155                  -26962,        /* A2 = -0.822845 */
10156                  -2914,         /* B2 = -0.088936 */
10157                  0,             /* B1 = 0 */
10158                  2914,          /* B0 = 0.088936 */
10159                  14119,         /* A1 = 0.861786 */
10160                  -30227,        /* A2 = -0.922455 */
10161                  11466,         /* B2 = 0.349945 */
10162                  -2833,         /* B1 = -0.172943 */
10163                  11466,         /* B0 = 0.349945 */
10164                  23431,         /* A1 = 1.430115 */
10165                  -30828,        /* A2 = -0.940796 */
10166                  25331,         /* B2 = 0.773071 */
10167                  -20911,        /* B1 = -1.276367 */
10168                  25331,         /* B0 = 0.773071 */
10169                  7,             /* Internal filter scaling */
10170                  159,           /* Minimum in-band energy threshold */
10171                  21,            /* 21/32 in-band to broad-band ratio */
10172                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10173         },
10174         {                       /* f975 */
10175                 23521,          /* A1 = -1.435608 */
10176                  -32489,        /* A2 = 0.991516 */
10177                  -193,          /* B2 = -0.005915 */
10178                  0,             /* B1 = 0.000000 */
10179                  193,           /* B0 = 0.005915 */
10180                  23404,         /* A1 = -1.428467 */
10181                  -32655,        /* A2 = 0.996582 */
10182                  17740,         /* B2 = 0.541412 */
10183                  -12567,        /* B1 = -0.767029 */
10184                  17740,         /* B0 = 0.541412 */
10185                  23753,         /* A1 = -1.449829 */
10186                  -32657,        /* A2 = 0.996613 */
10187                  9090,          /* B2 = 0.277405 */
10188                  -6662,         /* B1 = -0.406647 */
10189                  9090,          /* B0 = 0.277405 */
10190                  5,             /* Internal filter scaling */
10191                  159,           /* Minimum in-band energy threshold */
10192                  21,            /* 21/32 in-band to broad-band ratio */
10193                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10194         },
10195         {                       /* f1000 */
10196                 23071,          /* A1 = -1.408203 */
10197                  -32489,        /* A2 = 0.991516 */
10198                  -293,          /* B2 = -0.008965 */
10199                  0,             /* B1 = 0.000000 */
10200                  293,           /* B0 = 0.008965 */
10201                  22951,         /* A1 = -1.400818 */
10202                  -32655,        /* A2 = 0.996582 */
10203                  5689,          /* B2 = 0.173645 */
10204                  -3951,         /* B1 = -0.241150 */
10205                  5689,          /* B0 = 0.173645 */
10206                  23307,         /* A1 = -1.422607 */
10207                  -32657,        /* A2 = 0.996613 */
10208                  18692,         /* B2 = 0.570435 */
10209                  -13447,        /* B1 = -0.820770 */
10210                  18692,         /* B0 = 0.570435 */
10211                  5,             /* Internal filter scaling */
10212                  159,           /* Minimum in-band energy threshold */
10213                  21,            /* 21/32 in-band to broad-band ratio */
10214                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10215         },
10216         {                       /* f1020 */
10217                 22701,          /* A1 = -1.385620 */
10218                  -32474,        /* A2 = 0.991058 */
10219                  -292,          /* B2 = -0.008933 */
10220                  0,             /*163840      , B1 = 10.000000 */
10221                  292,           /* B0 = 0.008933 */
10222                  22564,         /* A1 = -1.377258 */
10223                  -32655,        /* A2 = 0.996552 */
10224                  20756,         /* B2 = 0.633423 */
10225                  -14176,        /* B1 = -0.865295 */
10226                  20756,         /* B0 = 0.633423 */
10227                  22960,         /* A1 = -1.401428 */
10228                  -32657,        /* A2 = 0.996613 */
10229                  6520,          /* B2 = 0.198990 */
10230                  -4619,         /* B1 = -0.281937 */
10231                  6520,          /* B0 = 0.198990 */
10232                  5,             /* Internal filter scaling */
10233                  159,           /* Minimum in-band energy threshold */
10234                  21,            /* 21/32 in-band to broad-band ratio */
10235                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10236         },
10237         {                       /* f1050 */
10238                 22142,          /* A1 = -1.351501 */
10239                  -32474,        /* A2 = 0.991058 */
10240                  -147,          /* B2 = -0.004493 */
10241                  0,             /* B1 = 0.000000 */
10242                  147,           /* B0 = 0.004493 */
10243                  22000,         /* A1 = -1.342834 */
10244                  -32655,        /* A2 = 0.996552 */
10245                  15379,         /* B2 = 0.469360 */
10246                  -10237,        /* B1 = -0.624847 */
10247                  15379,         /* B0 = 0.469360 */
10248                  22406,         /* A1 = -1.367554 */
10249                  -32657,        /* A2 = 0.996613 */
10250                  17491,         /* B2 = 0.533783 */
10251                  -12096,        /* B1 = -0.738312 */
10252                  17491,         /* B0 = 0.533783 */
10253                  5,             /* Internal filter scaling */
10254                  159,           /* Minimum in-band energy threshold */
10255                  21,            /* 21/32 in-band to broad-band ratio */
10256                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10257         },
10258         {                       /* f1100_1750[] */
10259                 12973,          /* A1 = 0.79184 */
10260                  -24916,        /* A2 = -0.760376 */
10261                  6655,          /* B2 = 0.203102 */
10262                  367,           /* B1 = 0.0224 */
10263                  6657,          /* B0 = 0.203171 */
10264                  5915,          /* A1 = 0.361053 */
10265                  -29560,        /* A2 = -0.90213 */
10266                  -7777,         /* B2 = -0.23735 */
10267                  0,             /* B1 = 0 */
10268                  7777,          /* B0 = 0.23735 */
10269                  20510,         /* A1 = 1.251892 */
10270                  -30260,        /* A2 = -0.923462 */
10271                  26662,         /* B2 = 0.81366 */
10272                  -20573,        /* B1 = -1.255737 */
10273                  26668,         /* B0 = 0.813843 */
10274                  7,             /* Internal filter scaling */
10275                  159,           /* Minimum in-band energy threshold */
10276                  21,            /* 21/32 in-band to broad-band ratio */
10277                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10278         },
10279         {                       /* f1140 */
10280                 20392,          /* A1 = -1.244629 */
10281                  -32460,        /* A2 = 0.990601 */
10282                  -270,          /* B2 = -0.008240 */
10283                  0,             /* B1 = 0.000000 */
10284                  270,           /* B0 = 0.008240 */
10285                  20218,         /* A1 = -1.234009 */
10286                  -32655,        /* A2 = 0.996582 */
10287                  21337,         /* B2 = 0.651154 */
10288                  -13044,        /* B1 = -0.796143 */
10289                  21337,         /* B0 = 0.651154 */
10290                  20684,         /* A1 = -1.262512 */
10291                  -32657,        /* A2 = 0.996643 */
10292                  8572,          /* B2 = 0.261612 */
10293                  -5476,         /* B1 = -0.334244 */
10294                  8572,          /* B0 = 0.261612 */
10295                  5,             /* Internal filter scaling */
10296                  159,           /* Minimum in-band energy threshold */
10297                  21,            /* 21/32 in-band to broad-band ratio */
10298                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10299         },
10300         {                       /* f1200 */
10301                 19159,          /* A1 = -1.169373 */
10302                  -32456,        /* A2 = 0.990509 */
10303                  -335,          /* B2 = -0.010252 */
10304                  0,             /* B1 = 0.000000 */
10305                  335,           /* B0 = 0.010252 */
10306                  18966,         /* A1 = -1.157593 */
10307                  -32661,        /* A2 = 0.996735 */
10308                  6802,          /* B2 = 0.207588 */
10309                  -3900,         /* B1 = -0.238098 */
10310                  6802,          /* B0 = 0.207588 */
10311                  19467,         /* A1 = -1.188232 */
10312                  -32661,        /* A2 = 0.996765 */
10313                  25035,         /* B2 = 0.764008 */
10314                  -15049,        /* B1 = -0.918579 */
10315                  25035,         /* B0 = 0.764008 */
10316                  5,             /* Internal filter scaling */
10317                  159,           /* Minimum in-band energy threshold */
10318                  21,            /* 21/32 in-band to broad-band ratio */
10319                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10320         },
10321         {                       /* f1209 */
10322                 18976,          /* A1 = -1.158264 */
10323                  -32439,        /* A2 = 0.989990 */
10324                  -183,          /* B2 = -0.005588 */
10325                  0,             /* B1 = 0.000000 */
10326                  183,           /* B0 = 0.005588 */
10327                  18774,         /* A1 = -1.145874 */
10328                  -32650,        /* A2 = 0.996429 */
10329                  15468,         /* B2 = 0.472076 */
10330                  -8768,         /* B1 = -0.535217 */
10331                  15468,         /* B0 = 0.472076 */
10332                  19300,         /* A1 = -1.177979 */
10333                  -32652,        /* A2 = 0.996490 */
10334                  19840,         /* B2 = 0.605499 */
10335                  -11842,        /* B1 = -0.722809 */
10336                  19840,         /* B0 = 0.605499 */
10337                  5,             /* Internal filter scaling */
10338                  159,           /* Minimum in-band energy threshold */
10339                  21,            /* 21/32 in-band to broad-band ratio */
10340                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10341         },
10342         {                       /* f1330 */
10343                 16357,          /* A1 = -0.998413 */
10344                  -32368,        /* A2 = 0.987793 */
10345                  -217,          /* B2 = -0.006652 */
10346                  0,             /* B1 = 0.000000 */
10347                  217,           /* B0 = 0.006652 */
10348                  16107,         /* A1 = -0.983126 */
10349                  -32601,        /* A2 = 0.994904 */
10350                  11602,         /* B2 = 0.354065 */
10351                  -5555,         /* B1 = -0.339111 */
10352                  11602,         /* B0 = 0.354065 */
10353                  16722,         /* A1 = -1.020630 */
10354                  -32603,        /* A2 = 0.994965 */
10355                  15574,         /* B2 = 0.475311 */
10356                  -8176,         /* B1 = -0.499069 */
10357                  15574,         /* B0 = 0.475311 */
10358                  5,             /* Internal filter scaling */
10359                  159,           /* Minimum in-band energy threshold */
10360                  21,            /* 21/32 in-band to broad-band ratio */
10361                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10362         },
10363         {                       /* f1336 */
10364                 16234,          /* A1 = -0.990875 */
10365                  32404,         /* A2 = -0.988922 */
10366                  -193,          /* B2 = -0.005908 */
10367                  0,             /* B1 = 0.000000 */
10368                  193,           /* B0 = 0.005908 */
10369                  15986,         /* A1 = -0.975769 */
10370                  -32632,        /* A2 = 0.995880 */
10371                  18051,         /* B2 = 0.550903 */
10372                  -8658,         /* B1 = -0.528473 */
10373                  18051,         /* B0 = 0.550903 */
10374                  16591,         /* A1 = -1.012695 */
10375                  -32634,        /* A2 = 0.995941 */
10376                  15736,         /* B2 = 0.480240 */
10377                  -8125,         /* B1 = -0.495926 */
10378                  15736,         /* B0 = 0.480240 */
10379                  5,             /* Internal filter scaling */
10380                  159,           /* Minimum in-band energy threshold */
10381                  21,            /* 21/32 in-band to broad-band ratio */
10382                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10383         },
10384         {                       /* f1366 */
10385                 15564,          /* A1 = -0.949982 */
10386                  -32404,        /* A2 = 0.988922 */
10387                  -269,          /* B2 = -0.008216 */
10388                  0,             /* B1 = 0.000000 */
10389                  269,           /* B0 = 0.008216 */
10390                  15310,         /* A1 = -0.934479 */
10391                  -32632,        /* A2 = 0.995880 */
10392                  10815,         /* B2 = 0.330063 */
10393                  -4962,         /* B1 = -0.302887 */
10394                  10815,         /* B0 = 0.330063 */
10395                  15924,         /* A1 = -0.971924 */
10396                  -32634,        /* A2 = 0.995941 */
10397                  18880,         /* B2 = 0.576172 */
10398                  -9364,         /* B1 = -0.571594 */
10399                  18880,         /* B0 = 0.576172 */
10400                  5,             /* Internal filter scaling */
10401                  159,           /* Minimum in-band energy threshold */
10402                  21,            /* 21/32 in-band to broad-band ratio */
10403                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10404         },
10405         {                       /* f1380 */
10406                 15247,          /* A1 = -0.930603 */
10407                  -32397,        /* A2 = 0.988708 */
10408                  -244,          /* B2 = -0.007451 */
10409                  0,             /* B1 = 0.000000 */
10410                  244,           /* B0 = 0.007451 */
10411                  14989,         /* A1 = -0.914886 */
10412                  -32627,        /* A2 = 0.995697 */
10413                  18961,         /* B2 = 0.578644 */
10414                  -8498,         /* B1 = -0.518707 */
10415                  18961,         /* B0 = 0.578644 */
10416                  15608,         /* A1 = -0.952667 */
10417                  -32628,        /* A2 = 0.995758 */
10418                  11145,         /* B2 = 0.340134 */
10419                  -5430,         /* B1 = -0.331467 */
10420                  11145,         /* B0 = 0.340134 */
10421                  5,             /* Internal filter scaling */
10422                  159,           /* Minimum in-band energy threshold */
10423                  21,            /* 21/32 in-band to broad-band ratio */
10424                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10425         },
10426         {                       /* f1400 */
10427                 14780,          /* A1 = -0.902130 */
10428                  -32393,        /* A2 = 0.988586 */
10429                  -396,          /* B2 = -0.012086 */
10430                  0,             /* B1 = 0.000000 */
10431                  396,           /* B0 = 0.012086 */
10432                  14510,         /* A1 = -0.885651 */
10433                  -32630,        /* A2 = 0.995819 */
10434                  6326,          /* B2 = 0.193069 */
10435                  -2747,         /* B1 = -0.167671 */
10436                  6326,          /* B0 = 0.193069 */
10437                  15154,         /* A1 = -0.924957 */
10438                  -32632,        /* A2 = 0.995850 */
10439                  23235,         /* B2 = 0.709076 */
10440                  -10983,        /* B1 = -0.670380 */
10441                  23235,         /* B0 = 0.709076 */
10442                  5,             /* Internal filter scaling */
10443                  159,           /* Minimum in-band energy threshold */
10444                  21,            /* 21/32 in-band to broad-band ratio */
10445                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10446         },
10447         {                       /* f1477 */
10448                 13005,          /* A1 = -0.793793 */
10449                  -32368,        /* A2 = 0.987823 */
10450                  -500,          /* B2 = -0.015265 */
10451                  0,             /* B1 = 0.000000 */
10452                  500,           /* B0 = 0.015265 */
10453                  12708,         /* A1 = -0.775665 */
10454                  -32615,        /* A2 = 0.995331 */
10455                  11420,         /* B2 = 0.348526 */
10456                  -4306,         /* B1 = -0.262833 */
10457                  11420,         /* B0 = 0.348526 */
10458                  13397,         /* A1 = -0.817688 */
10459                  -32615,        /* A2 = 0.995361 */
10460                  9454,          /* B2 = 0.288528 */
10461                  -3981,         /* B1 = -0.243027 */
10462                  9454,          /* B0 = 0.288528 */
10463                  5,             /* Internal filter scaling */
10464                  159,           /* Minimum in-band energy threshold */
10465                  21,            /* 21/32 in-band to broad-band ratio */
10466                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10467         },
10468         {                       /* f1600 */
10469                 10046,          /* A1 = -0.613190 */
10470                  -32331,        /* A2 = 0.986694 */
10471                  -455,          /* B2 = -0.013915 */
10472                  0,             /* B1 = 0.000000 */
10473                  455,           /* B0 = 0.013915 */
10474                  9694,          /* A1 = -0.591705 */
10475                  -32601,        /* A2 = 0.994934 */
10476                  6023,          /* B2 = 0.183815 */
10477                  -1708,         /* B1 = -0.104279 */
10478                  6023,          /* B0 = 0.183815 */
10479                  10478,         /* A1 = -0.639587 */
10480                  -32603,        /* A2 = 0.994965 */
10481                  22031,         /* B2 = 0.672333 */
10482                  -7342,         /* B1 = -0.448151 */
10483                  22031,         /* B0 = 0.672333 */
10484                  5,             /* Internal filter scaling */
10485                  159,           /* Minimum in-band energy threshold */
10486                  21,            /* 21/32 in-band to broad-band ratio */
10487                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10488         },
10489         {                       /* f1633_1638[] */
10490                 9181,           /* A1 = 0.560394 */
10491                  -32256,        /* A2 = -0.984375 */
10492                  -556,          /* B2 = -0.016975 */
10493                  0,             /* B1 = 0 */
10494                  556,           /* B0 = 0.016975 */
10495                  8757,          /* A1 = 0.534515 */
10496                  -32574,        /* A2 = -0.99408 */
10497                  8443,          /* B2 = 0.25769 */
10498                  -2135,         /* B1 = -0.130341 */
10499                  8443,          /* B0 = 0.25769 */
10500                  9691,          /* A1 = 0.591522 */
10501                  -32574,        /* A2 = -0.99411 */
10502                  15446,         /* B2 = 0.471375 */
10503                  -4809,         /* B1 = -0.293579 */
10504                  15446,         /* B0 = 0.471375 */
10505                  7,             /* Internal filter scaling */
10506                  159,           /* Minimum in-band energy threshold */
10507                  21,            /* 21/32 in-band to broad-band ratio */
10508                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10509         },
10510         {                       /* f1800 */
10511                 5076,           /* A1 = -0.309875 */
10512                  -32304,        /* A2 = 0.985840 */
10513                  -508,          /* B2 = -0.015503 */
10514                  0,             /* B1 = 0.000000 */
10515                  508,           /* B0 = 0.015503 */
10516                  4646,          /* A1 = -0.283600 */
10517                  -32605,        /* A2 = 0.995026 */
10518                  6742,          /* B2 = 0.205780 */
10519                  -878,          /* B1 = -0.053635 */
10520                  6742,          /* B0 = 0.205780 */
10521                  5552,          /* A1 = -0.338928 */
10522                  -32605,        /* A2 = 0.995056 */
10523                  23667,         /* B2 = 0.722260 */
10524                  -4297,         /* B1 = -0.262329 */
10525                  23667,         /* B0 = 0.722260 */
10526                  5,             /* Internal filter scaling */
10527                  159,           /* Minimum in-band energy threshold */
10528                  21,            /* 21/32 in-band to broad-band ratio */
10529                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10530         },
10531         {                       /* f1860 */
10532                 3569,           /* A1 = -0.217865 */
10533                  -32292,        /* A2 = 0.985504 */
10534                  -239,          /* B2 = -0.007322 */
10535                  0,             /* B1 = 0.000000 */
10536                  239,           /* B0 = 0.007322 */
10537                  3117,          /* A1 = -0.190277 */
10538                  -32603,        /* A2 = 0.994965 */
10539                  18658,         /* B2 = 0.569427 */
10540                  -1557,         /* B1 = -0.095032 */
10541                  18658,         /* B0 = 0.569427 */
10542                  4054,          /* A1 = -0.247437 */
10543                  -32603,        /* A2 = 0.994965 */
10544                  18886,         /* B2 = 0.576385 */
10545                  -2566,         /* B1 = -0.156647 */
10546                  18886,         /* B0 = 0.576385 */
10547                  5,             /* Internal filter scaling */
10548                  159,           /* Minimum in-band energy threshold */
10549                  21,            /* 21/32 in-band to broad-band ratio */
10550                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10551         },
10552 };
10553 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10554 {
10555         unsigned short cmd;
10556         int cnt, max;
10557
10558         if (jf->filter > 3) {
10559                 return -1;
10560         }
10561         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10562
10563                 return -1;
10564         if (!jf->enable) {
10565                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10566
10567                         return -1;
10568                 else
10569                         return 0;
10570         } else {
10571                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10572
10573                         return -1;
10574                 /* Select the filter (f0 - f3) to use. */
10575                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10576                         return -1;
10577         }
10578         if (jf->freq < 12 && jf->freq > 3) {
10579                 /* Select the frequency for the selected filter. */
10580                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10581                         return -1;
10582         } else if (jf->freq > 11) {
10583                 /* We need to load a programmable filter set for undefined */
10584                 /* frequencies.  So we will point the filter to a programmable set. */
10585                 /* Since there are only 4 filters and 4 programmable sets, we will */
10586                 /* just point the filter to the same number set and program it for the */
10587                 /* frequency we want. */
10588                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10589                         return -1;
10590                 if (j->ver.low != 0x12) {
10591                         cmd = 0x515B;
10592                         max = 19;
10593                 } else {
10594                         cmd = 0x515E;
10595                         max = 15;
10596                 }
10597                 if (ixj_WriteDSPCommand(cmd, j))
10598                         return -1;
10599                 for (cnt = 0; cnt < max; cnt++) {
10600                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10601                                 return -1;
10602                 }
10603         }
10604         j->filter_en[jf->filter] = jf->enable;
10605         return 0;
10606 }
10607
10608 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10609 {
10610         unsigned short cmd;
10611         int cnt, max;
10612         if (jfr->filter > 3) {
10613                 return -1;
10614         }
10615         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10616                 return -1;
10617
10618         if (!jfr->enable) {
10619                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10620                         return -1;
10621                 else
10622                         return 0;
10623         } else {
10624                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10625                         return -1;
10626                 /* Select the filter (f0 - f3) to use. */
10627                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10628                         return -1;
10629         }
10630         /* We need to load a programmable filter set for undefined */
10631         /* frequencies.  So we will point the filter to a programmable set. */
10632         /* Since there are only 4 filters and 4 programmable sets, we will */
10633         /* just point the filter to the same number set and program it for the */
10634         /* frequency we want. */
10635         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10636                 return -1;
10637         if (j->ver.low != 0x12) {
10638                 cmd = 0x515B;
10639                 max = 19;
10640         } else {
10641                 cmd = 0x515E;
10642                 max = 15;
10643         }
10644         if (ixj_WriteDSPCommand(cmd, j))
10645                 return -1;
10646         for (cnt = 0; cnt < max; cnt++) {
10647                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10648                         return -1;
10649         }
10650         j->filter_en[jfr->filter] = jfr->enable;
10651         return 0;
10652 }
10653
10654 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10655 {
10656         int freq0, freq1;
10657         unsigned short data;
10658         if (ti->freq0) {
10659                 freq0 = ti->freq0;
10660         } else {
10661                 freq0 = 0x7FFF;
10662         }
10663
10664         if (ti->freq1) {
10665                 freq1 = ti->freq1;
10666         } else {
10667                 freq1 = 0x7FFF;
10668         }
10669
10670         if(ti->tone_index > 12 && ti->tone_index < 28)
10671         {
10672                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10673                         return -1;
10674                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10675                         return -1;
10676                 data = freq0;
10677                 if (ixj_WriteDSPCommand(data, j))
10678                         return -1;
10679                 data = freq1;
10680                 if (ixj_WriteDSPCommand(data, j))
10681                         return -1;
10682         }
10683         return freq0;
10684 }
10685