Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ixj.c
Go to the documentation of this file.
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, <[email protected]>
17  *
18  * Contributors: Greg Herlein, <[email protected]>
19  * David W. Erhart, <[email protected]>
20  * John Sellers, <[email protected]>
21  * Mike Preston, <[email protected]>
22  *
23  * Fixes: David Huggins-Daines, <[email protected]>
24  * Fabio Ferrari, <[email protected]>
25  * Artis Kugevics, <[email protected]>
26  * Daniele Bellucci, <[email protected]>
27  *
28  * More information about the hardware related to this driver can be found
29  * at our website: http://www.quicknet.net
30  *
31  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34  * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  *
36  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38  * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41  *
42  ***************************************************************************/
43 
44 /*
45  * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
46  * Audit some copy_*_user and minor cleanup.
47  *
48  * Revision 4.7 2001/08/13 06:19:33 craigs
49  * Added additional changes from Alan Cox and John Anderson for
50  * 2.2 to 2.4 cleanup and bounds checking
51  *
52  * Revision 4.6 2001/08/13 01:05:05 craigs
53  * Really fixed PHONE_QUERY_CODEC problem this time
54  *
55  * Revision 4.5 2001/08/13 00:11:03 craigs
56  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57  *
58  * Revision 4.4 2001/08/07 07:58:12 craigs
59  * Changed back to three digit version numbers
60  * Added tagbuild target to allow automatic and easy tagging of versions
61  *
62  * Revision 4.3 2001/08/07 07:24:47 craigs
63  * Added ixj-ver.h to allow easy configuration management of driver
64  * Added display of version number in /prox/ixj
65  *
66  * Revision 4.2 2001/08/06 07:07:19 craigs
67  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68  * behaviour of returning int rather than short *
69  *
70  * Revision 4.1 2001/08/05 00:17:37 craigs
71  * More changes for correct PCMCIA installation
72  * Start of changes for backward Linux compatibility
73  *
74  * Revision 4.0 2001/08/04 12:33:12 craigs
75  * New version using GNU autoconf
76  *
77  * Revision 3.105 2001/07/20 23:14:32 eokerson
78  * More work on CallerID generation when using ring cadences.
79  *
80  * Revision 3.104 2001/07/06 01:33:55 eokerson
81  * Some bugfixes from Robert Vojta <[email protected]> and a few mods to the Makefile.
82  *
83  * Revision 3.103 2001/07/05 19:20:16 eokerson
84  * Updated HOWTO
85  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86  *
87  * Revision 3.102 2001/07/03 23:51:21 eokerson
88  * Un-mute mic on Internet LineJACK when in speakerphone mode.
89  *
90  * Revision 3.101 2001/07/02 19:26:56 eokerson
91  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92  *
93  * Revision 3.100 2001/07/02 19:18:27 eokerson
94  * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96  * Fixed speaker mode on Internet LineJACK.
97  *
98  * Revision 3.99 2001/05/09 14:11:16 eokerson
99  * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <[email protected]>.
100  *
101  * Revision 3.98 2001/05/08 19:55:33 eokerson
102  * Fixed POTS hookstate detection while it is connected to PSTN port.
103  *
104  * Revision 3.97 2001/05/08 00:01:04 eokerson
105  * Fixed kernel oops when sending caller ID data.
106  *
107  * Revision 3.96 2001/05/04 23:09:30 eokerson
108  * Now uses one kernel timer for each card, instead of one for the entire driver.
109  *
110  * Revision 3.95 2001/04/25 22:06:47 eokerson
111  * Fixed squawking at beginning of some G.723.1 calls.
112  *
113  * Revision 3.94 2001/04/03 23:42:00 eokerson
114  * Added linear volume ioctls
115  * Added raw filter load ioctl
116  *
117  * Revision 3.93 2001/02/27 01:00:06 eokerson
118  * Fixed blocking in CallerID.
119  * Reduced size of ixj structure for smaller driver footprint.
120  *
121  * Revision 3.92 2001/02/20 22:02:59 eokerson
122  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123  * Improved PSTN ring detection.
124  * Fixed wink generation on POTS ports.
125  *
126  * Revision 3.91 2001/02/13 00:55:44 eokerson
127  * Turn AEC back on after changing frame sizes.
128  *
129  * Revision 3.90 2001/02/12 16:42:00 eokerson
130  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131  *
132  * Revision 3.89 2001/02/12 15:41:16 eokerson
133  * Fix from Artis Kugevics - Tone gains were not being set correctly.
134  *
135  * Revision 3.88 2001/02/05 23:25:42 eokerson
136  * Fixed lockup bugs with deregister.
137  *
138  * Revision 3.87 2001/01/29 21:00:39 eokerson
139  * Fix from Fabio Ferrari <[email protected]> to properly handle EAGAIN and EINTR during non-blocking write.
140  * Updated copyright date.
141  *
142  * Revision 3.86 2001/01/23 23:53:46 eokerson
143  * Fixes to G.729 compatibility.
144  *
145  * Revision 3.85 2001/01/23 21:30:36 eokerson
146  * Added verbage about cards supported.
147  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148  *
149  * Revision 3.84 2001/01/22 23:32:10 eokerson
150  * Some bugfixes from David Huggins-Daines, <[email protected]> and other cleanups.
151  *
152  * Revision 3.83 2001/01/19 14:51:41 eokerson
153  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154  *
155  * Revision 3.82 2001/01/19 00:34:49 eokerson
156  * Added verbosity to write overlap errors.
157  *
158  * Revision 3.81 2001/01/18 23:56:54 eokerson
159  * Fixed PSTN line test functions.
160  *
161  * Revision 3.80 2001/01/18 22:29:27 eokerson
162  * Updated AEC/AGC values for different cards.
163  *
164  * Revision 3.79 2001/01/17 02:58:54 eokerson
165  * Fixed AEC reset after Caller ID.
166  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167  *
168  * Revision 3.78 2001/01/16 19:43:09 eokerson
169  * Added support for Linux 2.4.x kernels.
170  *
171  * Revision 3.77 2001/01/09 04:00:52 eokerson
172  * Linetest will now test the line, even if it has previously succeeded.
173  *
174  * Revision 3.76 2001/01/08 19:27:00 eokerson
175  * Fixed problem with standard cable on Internet PhoneCARD.
176  *
177  * Revision 3.75 2000/12/22 16:52:14 eokerson
178  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179  *
180  * Revision 3.74 2000/12/08 22:41:50 eokerson
181  * Added capability for G729B.
182  *
183  * Revision 3.73 2000/12/07 23:35:16 eokerson
184  * Added capability to have different ring pattern before CallerID data.
185  * Added hookstate checks in CallerID routines to stop FSK.
186  *
187  * Revision 3.72 2000/12/06 19:31:31 eokerson
188  * Modified signal behavior to only send one signal per event.
189  *
190  * Revision 3.71 2000/12/06 03:23:08 eokerson
191  * Fixed CallerID on Call Waiting.
192  *
193  * Revision 3.70 2000/12/04 21:29:37 eokerson
194  * Added checking to Smart Cable gain functions.
195  *
196  * Revision 3.69 2000/12/04 21:05:20 eokerson
197  * Changed ixjdebug levels.
198  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199  *
200  * Revision 3.68 2000/12/04 00:17:21 craigs
201  * Changed mixer voice gain to +6dB rather than 0dB
202  *
203  * Revision 3.67 2000/11/30 21:25:51 eokerson
204  * Fixed write signal errors.
205  *
206  * Revision 3.66 2000/11/29 22:42:44 eokerson
207  * Fixed PSTN ring detect problems.
208  *
209  * Revision 3.65 2000/11/29 07:31:55 craigs
210  * Added new 425Hz filter co-efficients
211  * Added card-specific DTMF prescaler initialisation
212  *
213  * Revision 3.64 2000/11/28 14:03:32 craigs
214  * Changed certain mixer initialisations to be 0dB rather than 12dB
215  * Added additional information to /proc/ixj
216  *
217  * Revision 3.63 2000/11/28 11:38:41 craigs
218  * Added display of AEC modes in AUTO and AGC mode
219  *
220  * Revision 3.62 2000/11/28 04:05:44 eokerson
221  * Improved PSTN ring detection routine.
222  *
223  * Revision 3.61 2000/11/27 21:53:12 eokerson
224  * Fixed flash detection.
225  *
226  * Revision 3.60 2000/11/27 15:57:29 eokerson
227  * More work on G.729 load routines.
228  *
229  * Revision 3.59 2000/11/25 21:55:12 eokerson
230  * Fixed errors in G.729 load routine.
231  *
232  * Revision 3.58 2000/11/25 04:08:29 eokerson
233  * Added board locks around G.729 and TS85 load routines.
234  *
235  * Revision 3.57 2000/11/24 05:35:17 craigs
236  * Added ability to retrieve mixer values on LineJACK
237  * Added complete initialisation of all mixer values at startup
238  * Fixed spelling mistake
239  *
240  * Revision 3.56 2000/11/23 02:52:11 robertj
241  * Added cvs change log keyword.
242  * Fixed bug in capabilities list when using G.729 module.
243  *
244  */
245 
246 #include "ixj-ver.h"
247 
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251 
252 #include <linux/module.h>
253 
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/mutex.h>
261 #include <linux/mm.h>
262 #include <linux/ioport.h>
263 #include <linux/interrupt.h>
264 #include <linux/proc_fs.h>
265 #include <linux/poll.h>
266 #include <linux/timer.h>
267 #include <linux/delay.h>
268 #include <linux/pci.h>
269 
270 #include <asm/io.h>
271 #include <asm/uaccess.h>
272 
273 #include <linux/isapnp.h>
274 
275 #include "ixj.h"
276 
277 #define TYPE(inode) (iminor(inode) >> 4)
278 #define NUM(inode) (iminor(inode) & 0xf)
279 
280 static DEFINE_MUTEX(ixj_mutex);
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284 
285 module_param(ixjdebug, int, 0);
286 
287 static DEFINE_PCI_DEVICE_TABLE(ixj_pci_tbl) = {
288  { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
289  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
290  { }
291 };
292 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
293 
294 /************************************************************************
295 *
296 * ixjdebug meanings are now bit mapped instead of level based
297 * Values can be or'ed together to turn on multiple messages
298 *
299 * bit 0 (0x0001) = any failure
300 * bit 1 (0x0002) = general messages
301 * bit 2 (0x0004) = POTS ringing related
302 * bit 3 (0x0008) = PSTN events
303 * bit 4 (0x0010) = PSTN Cadence state details
304 * bit 5 (0x0020) = Tone detection triggers
305 * bit 6 (0x0040) = Tone detection cadence details
306 * bit 7 (0x0080) = ioctl tracking
307 * bit 8 (0x0100) = signal tracking
308 * bit 9 (0x0200) = CallerID generation details
309 *
310 ************************************************************************/
311 
312 #ifdef IXJ_DYN_ALLOC
313 
314 static IXJ *ixj[IXJMAX];
315 #define get_ixj(b) ixj[(b)]
316 
317 /*
318  * Allocate a free IXJ device
319  */
320 
321 static IXJ *ixj_alloc()
322 {
323  for(cnt=0; cnt<IXJMAX; cnt++)
324  {
325  if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
326  {
327  j = kmalloc(sizeof(IXJ), GFP_KERNEL);
328  if (j == NULL)
329  return NULL;
330  ixj[cnt] = j;
331  return j;
332  }
333  }
334  return NULL;
335 }
336 
337 static void ixj_fsk_free(IXJ *j)
338 {
339  kfree(j->fskdata);
340  j->fskdata = NULL;
341 }
342 
343 static void ixj_fsk_alloc(IXJ *j)
344 {
345  if(!j->fskdata) {
346  j->fskdata = kmalloc(8000, GFP_KERNEL);
347  if (!j->fskdata) {
348  if(ixjdebug & 0x0200) {
349  printk("IXJ phone%d - allocate failed\n", j->board);
350  }
351  return;
352  } else {
353  j->fsksize = 8000;
354  if(ixjdebug & 0x0200) {
355  printk("IXJ phone%d - allocate succeeded\n", j->board);
356  }
357  }
358  }
359 }
360 
361 #else
362 
363 static IXJ ixj[IXJMAX];
364 #define get_ixj(b) (&ixj[(b)])
365 
366 /*
367  * Allocate a free IXJ device
368  */
369 
370 static IXJ *ixj_alloc(void)
371 {
372  int cnt;
373  for(cnt=0; cnt<IXJMAX; cnt++) {
374  if(!ixj[cnt].DSPbase)
375  return &ixj[cnt];
376  }
377  return NULL;
378 }
379 
380 static inline void ixj_fsk_free(IXJ *j) {;}
381 
382 static inline void ixj_fsk_alloc(IXJ *j)
383 {
384  j->fsksize = 8000;
385 }
386 
387 #endif
388 
389 #ifdef PERFMON_STATS
390 #define ixj_perfmon(x) ((x)++)
391 #else
392 #define ixj_perfmon(x) do { } while(0)
393 #endif
394 
395 static int ixj_convert_loaded;
396 
397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
398 
399 /************************************************************************
400 *
401 * These are function definitions to allow external modules to register
402 * enhanced functionality call backs.
403 *
404 ************************************************************************/
405 
406 static int Stub(IXJ * J, unsigned long arg)
407 {
408  return 0;
409 }
410 
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 
416 static void ixj_read_frame(IXJ *j);
417 static void ixj_write_frame(IXJ *j);
418 static void ixj_init_timer(IXJ *j);
419 static void ixj_add_timer(IXJ * j);
420 static void ixj_timeout(unsigned long ptr);
421 static int read_filters(IXJ *j);
422 static int LineMonitor(IXJ *j);
423 static int ixj_fasync(int fd, struct file *, int mode);
424 static int ixj_set_port(IXJ *j, int arg);
425 static int ixj_set_pots(IXJ *j, int arg);
426 static int ixj_hookstate(IXJ *j);
427 static int ixj_record_start(IXJ *j);
428 static void ixj_record_stop(IXJ *j);
429 static void set_rec_volume(IXJ *j, int volume);
430 static int get_rec_volume(IXJ *j);
431 static int set_rec_codec(IXJ *j, int rate);
432 static void ixj_vad(IXJ *j, int arg);
433 static int ixj_play_start(IXJ *j);
434 static void ixj_play_stop(IXJ *j);
435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
436 static int ixj_set_tone_off(unsigned short, IXJ *j);
437 static int ixj_play_tone(IXJ *j, char tone);
438 static void ixj_aec_start(IXJ *j, int level);
439 static int idle(IXJ *j);
440 static void ixj_ring_on(IXJ *j);
441 static void ixj_ring_off(IXJ *j);
442 static void aec_stop(IXJ *j);
443 static void ixj_ringback(IXJ *j);
444 static void ixj_busytone(IXJ *j);
445 static void ixj_dialtone(IXJ *j);
446 static void ixj_cpt_stop(IXJ *j);
447 static char daa_int_read(IXJ *j);
448 static char daa_CR_read(IXJ *j, int cr);
449 static int daa_set_mode(IXJ *j, int mode);
450 static int ixj_linetest(IXJ *j);
451 static int ixj_daa_write(IXJ *j);
452 static int ixj_daa_cid_read(IXJ *j);
453 static void DAA_Coeff_US(IXJ *j);
454 static void DAA_Coeff_UK(IXJ *j);
455 static void DAA_Coeff_France(IXJ *j);
456 static void DAA_Coeff_Germany(IXJ *j);
457 static void DAA_Coeff_Australia(IXJ *j);
458 static void DAA_Coeff_Japan(IXJ *j);
459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
464 /* Serial Control Interface funtions */
465 static int SCI_Control(IXJ *j, int control);
466 static int SCI_Prepare(IXJ *j);
467 static int SCI_WaitHighSCI(IXJ *j);
468 static int SCI_WaitLowSCI(IXJ *j);
469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
470 static int ixj_PCcontrol_wait(IXJ *j);
471 static void ixj_pre_cid(IXJ *j);
472 static void ixj_write_cid(IXJ *j);
473 static void ixj_write_cid_bit(IXJ *j, int bit);
474 static int set_base_frame(IXJ *j, int size);
475 static int set_play_codec(IXJ *j, int rate);
476 static void set_rec_depth(IXJ *j, int depth);
477 static int ixj_mixer(long val, IXJ *j);
478 
479 /************************************************************************
480 CT8020/CT8021 Host Programmers Model
481 Host address Function Access
482 DSPbase +
483 0-1 Aux Software Status Register (reserved) Read Only
484 2-3 Software Status Register Read Only
485 4-5 Aux Software Control Register (reserved) Read Write
486 6-7 Software Control Register Read Write
487 8-9 Hardware Status Register Read Only
488 A-B Hardware Control Register Read Write
489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
490 E-F Host Receive (Read) Data Buffer Access Port (buffer input) Read Only
491 ************************************************************************/
492 
493 static inline void ixj_read_HSR(IXJ *j)
494 {
495  j->hsr.bytes.low = inb_p(j->DSPbase + 8);
496  j->hsr.bytes.high = inb_p(j->DSPbase + 9);
497 }
498 
499 static inline int IsControlReady(IXJ *j)
500 {
501  ixj_read_HSR(j);
502  return j->hsr.bits.controlrdy ? 1 : 0;
503 }
504 
505 static inline int IsPCControlReady(IXJ *j)
506 {
507  j->pccr1.byte = inb_p(j->XILINXbase + 3);
508  return j->pccr1.bits.crr ? 1 : 0;
509 }
510 
511 static inline int IsStatusReady(IXJ *j)
512 {
513  ixj_read_HSR(j);
514  return j->hsr.bits.statusrdy ? 1 : 0;
515 }
516 
517 static inline int IsRxReady(IXJ *j)
518 {
519  ixj_read_HSR(j);
520  ixj_perfmon(j->rxreadycheck);
521  return j->hsr.bits.rxrdy ? 1 : 0;
522 }
523 
524 static inline int IsTxReady(IXJ *j)
525 {
526  ixj_read_HSR(j);
527  ixj_perfmon(j->txreadycheck);
528  return j->hsr.bits.txrdy ? 1 : 0;
529 }
530 
531 static inline void set_play_volume(IXJ *j, int volume)
532 {
533  if (ixjdebug & 0x0002)
534  printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
535  ixj_WriteDSPCommand(0xCF02, j);
536  ixj_WriteDSPCommand(volume, j);
537 }
538 
539 static int set_play_volume_linear(IXJ *j, int volume)
540 {
541  int newvolume, dspplaymax;
542 
543  if (ixjdebug & 0x0002)
544  printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
545  if(volume > 100 || volume < 0) {
546  return -1;
547  }
548 
549  /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
550  switch (j->cardtype) {
551  case QTI_PHONEJACK:
552  dspplaymax = 0x380;
553  break;
554  case QTI_LINEJACK:
555  if(j->port == PORT_PSTN) {
556  dspplaymax = 0x48;
557  } else {
558  dspplaymax = 0x100;
559  }
560  break;
561  case QTI_PHONEJACK_LITE:
562  dspplaymax = 0x380;
563  break;
564  case QTI_PHONEJACK_PCI:
565  dspplaymax = 0x6C;
566  break;
567  case QTI_PHONECARD:
568  dspplaymax = 0x50;
569  break;
570  default:
571  return -1;
572  }
573  newvolume = (dspplaymax * volume) / 100;
574  set_play_volume(j, newvolume);
575  return 0;
576 }
577 
578 static inline void set_play_depth(IXJ *j, int depth)
579 {
580  if (depth > 60)
581  depth = 60;
582  if (depth < 0)
583  depth = 0;
584  ixj_WriteDSPCommand(0x5280 + depth, j);
585 }
586 
587 static inline int get_play_volume(IXJ *j)
588 {
589  ixj_WriteDSPCommand(0xCF00, j);
590  return j->ssr.high << 8 | j->ssr.low;
591 }
592 
593 static int get_play_volume_linear(IXJ *j)
594 {
595  int volume, newvolume, dspplaymax;
596 
597  /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
598  switch (j->cardtype) {
599  case QTI_PHONEJACK:
600  dspplaymax = 0x380;
601  break;
602  case QTI_LINEJACK:
603  if(j->port == PORT_PSTN) {
604  dspplaymax = 0x48;
605  } else {
606  dspplaymax = 0x100;
607  }
608  break;
609  case QTI_PHONEJACK_LITE:
610  dspplaymax = 0x380;
611  break;
612  case QTI_PHONEJACK_PCI:
613  dspplaymax = 0x6C;
614  break;
615  case QTI_PHONECARD:
616  dspplaymax = 100;
617  break;
618  default:
619  return -1;
620  }
621  volume = get_play_volume(j);
622  newvolume = (volume * 100) / dspplaymax;
623  if(newvolume > 100)
624  newvolume = 100;
625  return newvolume;
626 }
627 
628 static inline BYTE SLIC_GetState(IXJ *j)
629 {
630  if (j->cardtype == QTI_PHONECARD) {
631  j->pccr1.byte = 0;
632  j->psccr.bits.dev = 3;
633  j->psccr.bits.rw = 1;
634  outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
635  ixj_PCcontrol_wait(j);
636  j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
637  ixj_PCcontrol_wait(j);
638  if (j->pslic.bits.powerdown)
639  return PLD_SLIC_STATE_OC;
640  else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
641  return PLD_SLIC_STATE_ACTIVE;
642  else
643  return PLD_SLIC_STATE_RINGING;
644  } else {
645  j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
646  }
647  return j->pld_slicr.bits.state;
648 }
649 
650 static bool SLIC_SetState(BYTE byState, IXJ *j)
651 {
652  bool fRetVal = false;
653 
654  if (j->cardtype == QTI_PHONECARD) {
655  if (j->flags.pcmciasct) {
656  switch (byState) {
657  case PLD_SLIC_STATE_TIPOPEN:
658  case PLD_SLIC_STATE_OC:
659  j->pslic.bits.powerdown = 1;
660  j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
661  fRetVal = true;
662  break;
663  case PLD_SLIC_STATE_RINGING:
664  if (j->readers || j->writers) {
665  j->pslic.bits.powerdown = 0;
666  j->pslic.bits.ring0 = 1;
667  j->pslic.bits.ring1 = 0;
668  fRetVal = true;
669  }
670  break;
671  case PLD_SLIC_STATE_OHT: /* On-hook transmit */
672 
673  case PLD_SLIC_STATE_STANDBY:
674  case PLD_SLIC_STATE_ACTIVE:
675  if (j->readers || j->writers) {
676  j->pslic.bits.powerdown = 0;
677  } else {
678  j->pslic.bits.powerdown = 1;
679  }
680  j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
681  fRetVal = true;
682  break;
683  case PLD_SLIC_STATE_APR: /* Active polarity reversal */
684 
685  case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
686 
687  default:
688  fRetVal = false;
689  break;
690  }
691  j->psccr.bits.dev = 3;
692  j->psccr.bits.rw = 0;
693  outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
694  ixj_PCcontrol_wait(j);
695  }
696  } else {
697  /* Set the C1, C2, C3 & B2EN signals. */
698  switch (byState) {
699  case PLD_SLIC_STATE_OC:
700  j->pld_slicw.bits.c1 = 0;
701  j->pld_slicw.bits.c2 = 0;
702  j->pld_slicw.bits.c3 = 0;
703  j->pld_slicw.bits.b2en = 0;
704  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
705  fRetVal = true;
706  break;
707  case PLD_SLIC_STATE_RINGING:
708  j->pld_slicw.bits.c1 = 1;
709  j->pld_slicw.bits.c2 = 0;
710  j->pld_slicw.bits.c3 = 0;
711  j->pld_slicw.bits.b2en = 1;
712  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
713  fRetVal = true;
714  break;
715  case PLD_SLIC_STATE_ACTIVE:
716  j->pld_slicw.bits.c1 = 0;
717  j->pld_slicw.bits.c2 = 1;
718  j->pld_slicw.bits.c3 = 0;
719  j->pld_slicw.bits.b2en = 0;
720  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
721  fRetVal = true;
722  break;
723  case PLD_SLIC_STATE_OHT: /* On-hook transmit */
724 
725  j->pld_slicw.bits.c1 = 1;
726  j->pld_slicw.bits.c2 = 1;
727  j->pld_slicw.bits.c3 = 0;
728  j->pld_slicw.bits.b2en = 0;
729  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
730  fRetVal = true;
731  break;
732  case PLD_SLIC_STATE_TIPOPEN:
733  j->pld_slicw.bits.c1 = 0;
734  j->pld_slicw.bits.c2 = 0;
735  j->pld_slicw.bits.c3 = 1;
736  j->pld_slicw.bits.b2en = 0;
737  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
738  fRetVal = true;
739  break;
740  case PLD_SLIC_STATE_STANDBY:
741  j->pld_slicw.bits.c1 = 1;
742  j->pld_slicw.bits.c2 = 0;
743  j->pld_slicw.bits.c3 = 1;
744  j->pld_slicw.bits.b2en = 1;
745  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
746  fRetVal = true;
747  break;
748  case PLD_SLIC_STATE_APR: /* Active polarity reversal */
749 
750  j->pld_slicw.bits.c1 = 0;
751  j->pld_slicw.bits.c2 = 1;
752  j->pld_slicw.bits.c3 = 1;
753  j->pld_slicw.bits.b2en = 0;
754  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
755  fRetVal = true;
756  break;
757  case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
758 
759  j->pld_slicw.bits.c1 = 1;
760  j->pld_slicw.bits.c2 = 1;
761  j->pld_slicw.bits.c3 = 1;
762  j->pld_slicw.bits.b2en = 0;
763  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
764  fRetVal = true;
765  break;
766  default:
767  fRetVal = false;
768  break;
769  }
770  }
771 
772  return fRetVal;
773 }
774 
775 static int ixj_wink(IXJ *j)
776 {
777  BYTE slicnow;
778 
779  slicnow = SLIC_GetState(j);
780 
781  j->pots_winkstart = jiffies;
782  SLIC_SetState(PLD_SLIC_STATE_OC, j);
783 
784  msleep(jiffies_to_msecs(j->winktime));
785 
786  SLIC_SetState(slicnow, j);
787  return 0;
788 }
789 
790 static void ixj_init_timer(IXJ *j)
791 {
792  init_timer(&j->timer);
793  j->timer.function = ixj_timeout;
794  j->timer.data = (unsigned long)j;
795 }
796 
797 static void ixj_add_timer(IXJ *j)
798 {
799  j->timer.expires = jiffies + (hertz / samplerate);
800  add_timer(&j->timer);
801 }
802 
803 static void ixj_tone_timeout(IXJ *j)
804 {
805  IXJ_TONE ti;
806 
807  j->tone_state++;
808  if (j->tone_state == 3) {
809  j->tone_state = 0;
810  if (j->cadence_t) {
811  j->tone_cadence_state++;
812  if (j->tone_cadence_state >= j->cadence_t->elements_used) {
813  switch (j->cadence_t->termination) {
814  case PLAY_ONCE:
815  ixj_cpt_stop(j);
816  break;
817  case REPEAT_LAST_ELEMENT:
818  j->tone_cadence_state--;
819  ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
820  break;
821  case REPEAT_ALL:
822  j->tone_cadence_state = 0;
823  if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
824  ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
825  ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
826  ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
827  ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
828  ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
829  ixj_init_tone(j, &ti);
830  }
831  ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
832  ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
833  ixj_play_tone(j, j->cadence_t->ce[0].index);
834  break;
835  }
836  } else {
837  if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
838  ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
839  ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
840  ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
841  ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
842  ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
843  ixj_init_tone(j, &ti);
844  }
845  ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
846  ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
847  ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
848  }
849  }
850  }
851 }
852 
853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
854 {
855  if(j->ixj_signals[event]) {
856  if(ixjdebug & 0x0100)
857  printk("Sending signal for event %d\n", event);
858  /* Send apps notice of change */
859  /* see config.h for macro definition */
860  kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
861  }
862 }
863 
864 static void ixj_pstn_state(IXJ *j)
865 {
866  int var;
867  union XOPXR0 XR0, daaint;
868 
869  var = 10;
870 
871  XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
872  daaint.reg = 0;
873  XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
874 
875  j->pld_scrr.byte = inb_p(j->XILINXbase);
876  if (j->pld_scrr.bits.daaflag) {
877  daa_int_read(j);
878  if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
879  if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
880  daaint.bitreg.RING = 1;
881  if(ixjdebug & 0x0008) {
882  printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
883  }
884  } else {
885  daa_set_mode(j, SOP_PU_RESET);
886  }
887  }
888  if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
889  daaint.bitreg.Caller_ID = 1;
890  j->pstn_cid_intr = 1;
891  j->pstn_cid_received = jiffies;
892  if(ixjdebug & 0x0008) {
893  printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
894  }
895  }
896  if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
897  daaint.bitreg.Cadence = 1;
898  if(ixjdebug & 0x0008) {
899  printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
900  }
901  }
902  if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
903  daaint.bitreg.VDD_OK = 1;
904  daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
905  }
906  }
907  daa_CR_read(j, 1);
908  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)) {
909  daaint.bitreg.RMR = 1;
910  daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
911  if(ixjdebug & 0x0008) {
912  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);
913  }
914  j->pstn_prev_rmr = j->pstn_last_rmr;
915  j->pstn_last_rmr = jiffies;
916  }
917  switch(j->daa_mode) {
918  case SOP_PU_SLEEP:
919  if (daaint.bitreg.RING) {
920  if (!j->flags.pstn_ringing) {
921  if (j->daa_mode != SOP_PU_RINGING) {
922  j->pstn_ring_int = jiffies;
923  daa_set_mode(j, SOP_PU_RINGING);
924  }
925  }
926  }
927  break;
928  case SOP_PU_RINGING:
929  if (daaint.bitreg.RMR) {
930  if (ixjdebug & 0x0008) {
931  printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
932  }
933  if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
934  j->flags.pstn_rmr = 1;
935  j->pstn_ring_start = jiffies;
936  j->pstn_ring_stop = 0;
937  j->ex.bits.pstn_ring = 0;
938  if (j->cadence_f[4].state == 0) {
939  j->cadence_f[4].state = 1;
940  j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
941  j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
942  j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
943  } else if (j->cadence_f[4].state == 2) {
944  if((time_after(jiffies, j->cadence_f[4].off1min) &&
945  time_before(jiffies, j->cadence_f[4].off1max))) {
946  if (j->cadence_f[4].on2) {
947  j->cadence_f[4].state = 3;
948  j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
949  j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
950  j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
951  } else {
952  j->cadence_f[4].state = 7;
953  }
954  } else {
955  if (ixjdebug & 0x0008) {
956  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
957  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
958  j->cadence_f[4].off1);
959  }
960  j->cadence_f[4].state = 0;
961  }
962  } else if (j->cadence_f[4].state == 4) {
963  if((time_after(jiffies, j->cadence_f[4].off2min) &&
964  time_before(jiffies, j->cadence_f[4].off2max))) {
965  if (j->cadence_f[4].on3) {
966  j->cadence_f[4].state = 5;
967  j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
968  j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
969  j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
970  } else {
971  j->cadence_f[4].state = 7;
972  }
973  } else {
974  if (ixjdebug & 0x0008) {
975  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
976  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
977  j->cadence_f[4].off2);
978  }
979  j->cadence_f[4].state = 0;
980  }
981  } else if (j->cadence_f[4].state == 6) {
982  if((time_after(jiffies, j->cadence_f[4].off3min) &&
983  time_before(jiffies, j->cadence_f[4].off3max))) {
984  j->cadence_f[4].state = 7;
985  } else {
986  if (ixjdebug & 0x0008) {
987  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
988  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
989  j->cadence_f[4].off3);
990  }
991  j->cadence_f[4].state = 0;
992  }
993  } else {
994  j->cadence_f[4].state = 0;
995  }
996  } else { /* Falling edge of RMR */
997  j->pstn_ring_start = 0;
998  j->pstn_ring_stop = jiffies;
999  if (j->cadence_f[4].state == 1) {
1000  if(!j->cadence_f[4].on1) {
1001  j->cadence_f[4].state = 7;
1002  } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003  time_before(jiffies, j->cadence_f[4].on1max))) {
1004  if (j->cadence_f[4].off1) {
1005  j->cadence_f[4].state = 2;
1006  j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007  j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008  j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009  } else {
1010  j->cadence_f[4].state = 7;
1011  }
1012  } else {
1013  if (ixjdebug & 0x0008) {
1014  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016  j->cadence_f[4].on1);
1017  }
1018  j->cadence_f[4].state = 0;
1019  }
1020  } else if (j->cadence_f[4].state == 3) {
1021  if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022  time_before(jiffies, j->cadence_f[4].on2max))) {
1023  if (j->cadence_f[4].off2) {
1024  j->cadence_f[4].state = 4;
1025  j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026  j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027  j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028  } else {
1029  j->cadence_f[4].state = 7;
1030  }
1031  } else {
1032  if (ixjdebug & 0x0008) {
1033  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035  j->cadence_f[4].on2);
1036  }
1037  j->cadence_f[4].state = 0;
1038  }
1039  } else if (j->cadence_f[4].state == 5) {
1040  if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041  time_before(jiffies, j->cadence_f[4].on3max))) {
1042  if (j->cadence_f[4].off3) {
1043  j->cadence_f[4].state = 6;
1044  j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045  j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046  j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047  } else {
1048  j->cadence_f[4].state = 7;
1049  }
1050  } else {
1051  j->cadence_f[4].state = 0;
1052  }
1053  } else {
1054  if (ixjdebug & 0x0008) {
1055  printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056  j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057  j->cadence_f[4].on3);
1058  }
1059  j->cadence_f[4].state = 0;
1060  }
1061  }
1062  if (ixjdebug & 0x0010) {
1063  printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064  }
1065  if (ixjdebug & 0x0010) {
1066  switch(j->cadence_f[4].state) {
1067  case 1:
1068  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069  j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070  break;
1071  case 2:
1072  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073  j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074  break;
1075  case 3:
1076  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077  j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078  break;
1079  case 4:
1080  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081  j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082  break;
1083  case 5:
1084  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085  j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086  break;
1087  case 6:
1088  printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089  j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090  break;
1091  }
1092  }
1093  }
1094  if (j->cadence_f[4].state == 7) {
1095  j->cadence_f[4].state = 0;
1096  j->pstn_ring_stop = jiffies;
1097  j->ex.bits.pstn_ring = 1;
1098  ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099  if(ixjdebug & 0x0008) {
1100  printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101  }
1102  }
1103  if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104  (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105  if(ixjdebug & 0x0008) {
1106  printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107  printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108  printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109  }
1110  j->pstn_ring_stop = j->pstn_ring_int = 0;
1111  daa_set_mode(j, SOP_PU_SLEEP);
1112  }
1113  outb_p(j->pld_scrw.byte, j->XILINXbase);
1114  if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115  ixj_daa_cid_read(j);
1116  j->ex.bits.caller_id = 1;
1117  ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118  j->pstn_cid_intr = 0;
1119  }
1120  if (daaint.bitreg.Cadence) {
1121  if(ixjdebug & 0x0008) {
1122  printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123  }
1124  daa_set_mode(j, SOP_PU_SLEEP);
1125  j->ex.bits.pstn_ring = 0;
1126  }
1127  break;
1128  case SOP_PU_CONVERSATION:
1129  if (daaint.bitreg.VDD_OK) {
1130  if(!daaint.bitreg.SI_0) {
1131  if (!j->pstn_winkstart) {
1132  if(ixjdebug & 0x0008) {
1133  printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134  }
1135  j->pstn_winkstart = jiffies;
1136  }
1137  } else {
1138  if (j->pstn_winkstart) {
1139  if(ixjdebug & 0x0008) {
1140  printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141  }
1142  j->pstn_winkstart = 0;
1143  }
1144  }
1145  }
1146  if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147  if(ixjdebug & 0x0008) {
1148  printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149  }
1150  daa_set_mode(j, SOP_PU_SLEEP);
1151  j->pstn_winkstart = 0;
1152  j->ex.bits.pstn_wink = 1;
1153  ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154  }
1155  break;
1156  }
1157 }
1158 
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161  int board;
1162  unsigned long jifon;
1163  IXJ *j = (IXJ *)ptr;
1164  board = j->board;
1165 
1166  if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167  ixj_perfmon(j->timerchecks);
1168  j->hookstate = ixj_hookstate(j);
1169  if (j->tone_state) {
1170  if (!(j->hookstate)) {
1171  ixj_cpt_stop(j);
1172  if (j->m_hook) {
1173  j->m_hook = 0;
1174  j->ex.bits.hookstate = 1;
1175  ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176  }
1177  clear_bit(board, &j->busyflags);
1178  ixj_add_timer(j);
1179  return;
1180  }
1181  if (j->tone_state == 1)
1182  jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183  else
1184  jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185  if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186  if (j->tone_state == 1) {
1187  ixj_play_tone(j, j->tone_index);
1188  if (j->dsp.low == 0x20) {
1189  clear_bit(board, &j->busyflags);
1190  ixj_add_timer(j);
1191  return;
1192  }
1193  } else {
1194  ixj_play_tone(j, 0);
1195  if (j->dsp.low == 0x20) {
1196  clear_bit(board, &j->busyflags);
1197  ixj_add_timer(j);
1198  return;
1199  }
1200  }
1201  } else {
1202  ixj_tone_timeout(j);
1203  if (j->flags.dialtone) {
1204  ixj_dialtone(j);
1205  }
1206  if (j->flags.busytone) {
1207  ixj_busytone(j);
1208  if (j->dsp.low == 0x20) {
1209  clear_bit(board, &j->busyflags);
1210  ixj_add_timer(j);
1211  return;
1212  }
1213  }
1214  if (j->flags.ringback) {
1215  ixj_ringback(j);
1216  if (j->dsp.low == 0x20) {
1217  clear_bit(board, &j->busyflags);
1218  ixj_add_timer(j);
1219  return;
1220  }
1221  }
1222  if (!j->tone_state) {
1223  ixj_cpt_stop(j);
1224  }
1225  }
1226  }
1227  if (!(j->tone_state && j->dsp.low == 0x20)) {
1228  if (IsRxReady(j)) {
1229  ixj_read_frame(j);
1230  }
1231  if (IsTxReady(j)) {
1232  ixj_write_frame(j);
1233  }
1234  }
1235  if (j->flags.cringing) {
1236  if (j->hookstate & 1) {
1237  j->flags.cringing = 0;
1238  ixj_ring_off(j);
1239  } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240  switch(j->cadence_f[5].state) {
1241  case 0:
1242  j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243  if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244  if(ixjdebug & 0x0004) {
1245  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246  }
1247  ixj_ring_on(j);
1248  }
1249  j->cadence_f[5].state = 1;
1250  break;
1251  case 1:
1252  if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253  j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254  if(ixjdebug & 0x0004) {
1255  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256  }
1257  ixj_ring_off(j);
1258  j->cadence_f[5].state = 2;
1259  }
1260  break;
1261  case 2:
1262  if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263  if(ixjdebug & 0x0004) {
1264  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265  }
1266  ixj_ring_on(j);
1267  if (j->cadence_f[5].on2) {
1268  j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269  j->cadence_f[5].state = 3;
1270  } else {
1271  j->cadence_f[5].state = 7;
1272  }
1273  }
1274  break;
1275  case 3:
1276  if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277  if(ixjdebug & 0x0004) {
1278  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279  }
1280  ixj_ring_off(j);
1281  if (j->cadence_f[5].off2) {
1282  j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283  j->cadence_f[5].state = 4;
1284  } else {
1285  j->cadence_f[5].state = 7;
1286  }
1287  }
1288  break;
1289  case 4:
1290  if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291  if(ixjdebug & 0x0004) {
1292  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293  }
1294  ixj_ring_on(j);
1295  if (j->cadence_f[5].on3) {
1296  j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297  j->cadence_f[5].state = 5;
1298  } else {
1299  j->cadence_f[5].state = 7;
1300  }
1301  }
1302  break;
1303  case 5:
1304  if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305  if(ixjdebug & 0x0004) {
1306  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307  }
1308  ixj_ring_off(j);
1309  if (j->cadence_f[5].off3) {
1310  j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311  j->cadence_f[5].state = 6;
1312  } else {
1313  j->cadence_f[5].state = 7;
1314  }
1315  }
1316  break;
1317  case 6:
1318  if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319  if(ixjdebug & 0x0004) {
1320  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321  }
1322  j->cadence_f[5].state = 7;
1323  }
1324  break;
1325  case 7:
1326  if(ixjdebug & 0x0004) {
1327  printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328  }
1329  j->flags.cidring = 1;
1330  j->cadence_f[5].state = 0;
1331  break;
1332  }
1333  if (j->flags.cidring && !j->flags.cidsent) {
1334  j->flags.cidsent = 1;
1335  if(j->fskdcnt) {
1336  SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337  ixj_pre_cid(j);
1338  }
1339  j->flags.cidring = 0;
1340  }
1341  clear_bit(board, &j->busyflags);
1342  ixj_add_timer(j);
1343  return;
1344  } else {
1345  if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346  if (j->flags.cidring && !j->flags.cidsent) {
1347  j->flags.cidsent = 1;
1348  if(j->fskdcnt) {
1349  SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350  ixj_pre_cid(j);
1351  }
1352  j->flags.cidring = 0;
1353  }
1354  j->ring_cadence_t--;
1355  if (j->ring_cadence_t == -1)
1356  j->ring_cadence_t = 15;
1357  j->ring_cadence_jif = jiffies;
1358 
1359  if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360  if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361  j->flags.firstring = 1;
1362  else
1363  ixj_ring_on(j);
1364  } else {
1365  ixj_ring_off(j);
1366  if(!j->flags.cidsent)
1367  j->flags.cidring = 1;
1368  }
1369  }
1370  clear_bit(board, &j->busyflags);
1371  ixj_add_timer(j);
1372  return;
1373  }
1374  }
1375  if (!j->flags.ringing) {
1376  if (j->hookstate) { /* & 1) { */
1377  if (j->dsp.low != 0x20 &&
1378  SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379  SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380  }
1381  LineMonitor(j);
1382  read_filters(j);
1383  ixj_WriteDSPCommand(0x511B, j);
1384  j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385  if (!j->m_hook && (j->hookstate & 1)) {
1386  j->m_hook = j->ex.bits.hookstate = 1;
1387  ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388  }
1389  } else {
1390  if (j->ex.bits.dtmf_ready) {
1391  j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392  }
1393  if (j->m_hook) {
1394  j->m_hook = 0;
1395  j->ex.bits.hookstate = 1;
1396  ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397  }
1398  }
1399  }
1400  if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401  ixj_pstn_state(j);
1402  }
1403  if (j->ex.bytes) {
1404  wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1405  }
1406  clear_bit(board, &j->busyflags);
1407  }
1408  ixj_add_timer(j);
1409 }
1410 
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413  unsigned long jif;
1414 
1415  jif = jiffies + ((60 * hertz) / 100);
1416  while (!IsStatusReady(j)) {
1417  ixj_perfmon(j->statuswait);
1418  if (time_after(jiffies, jif)) {
1419  ixj_perfmon(j->statuswaitfail);
1420  return -1;
1421  }
1422  }
1423  return 0;
1424 }
1425 
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428  unsigned long jif;
1429 
1430  jif = jiffies + ((60 * hertz) / 100);
1431  while (!IsPCControlReady(j)) {
1432  ixj_perfmon(j->pcontrolwait);
1433  if (time_after(jiffies, jif)) {
1434  ixj_perfmon(j->pcontrolwaitfail);
1435  return -1;
1436  }
1437  }
1438  return 0;
1439 }
1440 
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443  BYTES bytes;
1444  unsigned long jif;
1445 
1446  atomic_inc(&j->DSPWrite);
1447  if(atomic_read(&j->DSPWrite) > 1) {
1448  printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449  return -1;
1450  }
1451  bytes.high = (cmd & 0xFF00) >> 8;
1452  bytes.low = cmd & 0x00FF;
1453  jif = jiffies + ((60 * hertz) / 100);
1454  while (!IsControlReady(j)) {
1455  ixj_perfmon(j->iscontrolready);
1456  if (time_after(jiffies, jif)) {
1457  ixj_perfmon(j->iscontrolreadyfail);
1458  atomic_dec(&j->DSPWrite);
1459  if(atomic_read(&j->DSPWrite) > 0) {
1460  printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461  while(atomic_read(&j->DSPWrite) > 0) {
1462  atomic_dec(&j->DSPWrite);
1463  }
1464  }
1465  return -1;
1466  }
1467  }
1468  outb(bytes.low, j->DSPbase + 6);
1469  outb(bytes.high, j->DSPbase + 7);
1470 
1471  if (ixj_status_wait(j)) {
1472  j->ssr.low = 0xFF;
1473  j->ssr.high = 0xFF;
1474  atomic_dec(&j->DSPWrite);
1475  if(atomic_read(&j->DSPWrite) > 0) {
1476  printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477  while(atomic_read(&j->DSPWrite) > 0) {
1478  atomic_dec(&j->DSPWrite);
1479  }
1480  }
1481  return -1;
1482  }
1483 /* Read Software Status Register */
1484  j->ssr.low = inb_p(j->DSPbase + 2);
1485  j->ssr.high = inb_p(j->DSPbase + 3);
1486  atomic_dec(&j->DSPWrite);
1487  if(atomic_read(&j->DSPWrite) > 0) {
1488  printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489  while(atomic_read(&j->DSPWrite) > 0) {
1490  atomic_dec(&j->DSPWrite);
1491  }
1492  }
1493  return 0;
1494 }
1495 
1496 /***************************************************************************
1497 *
1498 * General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503  if (ixj_WriteDSPCommand(0x5143, j))
1504  return -1;
1505 
1506  j->gpio.bytes.low = j->ssr.low;
1507  j->gpio.bytes.high = j->ssr.high;
1508 
1509  return 0;
1510 }
1511 
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514  if (j->cardtype == QTI_LINEJACK) {
1515  j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516  j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517  j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518  j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519 
1520  outb(j->pld_scrw.byte, j->XILINXbase);
1521  }
1522 }
1523 
1524 /*********************************************************************
1525 * GPIO Pins are configured as follows on the Quicknet Internet
1526 * PhoneJACK Telephony Cards
1527 *
1528 * POTS Select GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540  if (j->cardtype == QTI_PHONEJACK_LITE) {
1541  if (arg != PORT_POTS)
1542  return 10;
1543  else
1544  return 0;
1545  }
1546  switch (arg) {
1547  case PORT_POTS:
1548  j->port = PORT_POTS;
1549  switch (j->cardtype) {
1550  case QTI_PHONECARD:
1551  if (j->flags.pcmciasct == 1)
1552  SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553  else
1554  return 11;
1555  break;
1556  case QTI_PHONEJACK_PCI:
1557  j->pld_slicw.pcib.mic = 0;
1558  j->pld_slicw.pcib.spk = 0;
1559  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560  break;
1561  case QTI_LINEJACK:
1562  ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1563  if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1564  Software Control Register */
1565  return 2;
1566  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1567 
1568  outb(j->pld_scrw.byte, j->XILINXbase);
1569  j->pld_clock.byte = 0;
1570  outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571  j->pld_slicw.bits.rly1 = 1;
1572  j->pld_slicw.bits.spken = 0;
1573  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574  ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1575  ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1576  ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1577  ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1578  ixj_mixer(0x0E80, j); /*Mic mute */
1579  ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1580  ixj_mixer(0x0080, j); /* Mute Master Left volume */
1581  ixj_mixer(0x0180, j); /* Mute Master Right volume */
1582  SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584  break;
1585  case QTI_PHONEJACK:
1586  j->gpio.bytes.high = 0x0B;
1587  j->gpio.bits.gpio6 = 0;
1588  j->gpio.bits.gpio7 = 0;
1589  ixj_WriteDSPCommand(j->gpio.word, j);
1590  break;
1591  }
1592  break;
1593  case PORT_PSTN:
1594  if (j->cardtype == QTI_LINEJACK) {
1595  ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596 
1597  j->pld_slicw.bits.rly3 = 0;
1598  j->pld_slicw.bits.rly1 = 1;
1599  j->pld_slicw.bits.spken = 0;
1600  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601  j->port = PORT_PSTN;
1602  } else {
1603  return 4;
1604  }
1605  break;
1606  case PORT_SPEAKER:
1607  j->port = PORT_SPEAKER;
1608  switch (j->cardtype) {
1609  case QTI_PHONECARD:
1610  if (j->flags.pcmciasct) {
1611  SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612  }
1613  break;
1614  case QTI_PHONEJACK_PCI:
1615  j->pld_slicw.pcib.mic = 1;
1616  j->pld_slicw.pcib.spk = 1;
1617  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618  break;
1619  case QTI_LINEJACK:
1620  ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1621  if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1622  Software Control Register */
1623  return 2;
1624  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1625 
1626  outb(j->pld_scrw.byte, j->XILINXbase);
1627  j->pld_clock.byte = 0;
1628  outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629  j->pld_slicw.bits.rly1 = 1;
1630  j->pld_slicw.bits.spken = 1;
1631  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632  ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1633  ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1634  ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1635  ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1636  ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1637  ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1638  ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1639  ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1640  break;
1641  case QTI_PHONEJACK:
1642  j->gpio.bytes.high = 0x0B;
1643  j->gpio.bits.gpio6 = 0;
1644  j->gpio.bits.gpio7 = 1;
1645  ixj_WriteDSPCommand(j->gpio.word, j);
1646  break;
1647  }
1648  break;
1649  case PORT_HANDSET:
1650  if (j->cardtype != QTI_PHONEJACK) {
1651  return 5;
1652  } else {
1653  j->gpio.bytes.high = 0x0B;
1654  j->gpio.bits.gpio6 = 1;
1655  j->gpio.bits.gpio7 = 0;
1656  ixj_WriteDSPCommand(j->gpio.word, j);
1657  j->port = PORT_HANDSET;
1658  }
1659  break;
1660  default:
1661  return 6;
1662  break;
1663  }
1664  return 0;
1665 }
1666 
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669  if (j->cardtype == QTI_LINEJACK) {
1670  if (arg) {
1671  if (j->port == PORT_PSTN) {
1672  j->pld_slicw.bits.rly1 = 0;
1673  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674  j->flags.pots_pstn = 1;
1675  return 1;
1676  } else {
1677  j->flags.pots_pstn = 0;
1678  return 0;
1679  }
1680  } else {
1681  j->pld_slicw.bits.rly1 = 1;
1682  outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683  j->flags.pots_pstn = 0;
1684  return 1;
1685  }
1686  } else {
1687  return 0;
1688  }
1689 }
1690 
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693  if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694  {
1695  if (ixjdebug & 0x0004)
1696  printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1697 
1698  j->gpio.bytes.high = 0x0B;
1699  j->gpio.bytes.low = 0x00;
1700  j->gpio.bits.gpio1 = 1;
1701  j->gpio.bits.gpio2 = 1;
1702  j->gpio.bits.gpio5 = 0;
1703  ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1704  } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705  {
1706  if (ixjdebug & 0x0004)
1707  printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708 
1709  SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710  }
1711 }
1712 
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715  if(j->cardtype == QTI_PHONECARD){
1716  if(j->flags.pcmciascp){
1717  if(val == -1)
1718  return j->siadc.bits.rxg;
1719 
1720  if(val < 0 || val > 0x1F)
1721  return -1;
1722 
1723  j->siadc.bits.hom = 0; /* Handset Out Mute */
1724  j->siadc.bits.lom = 0; /* Line Out Mute */
1725  j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1726  j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1727  j->psccr.bits.rw = 0; /* Read / Write flag */
1728  j->psccr.bits.dev = 0;
1729  outb(j->siadc.byte, j->XILINXbase + 0x00);
1730  outb(j->psccr.byte, j->XILINXbase + 0x01);
1731  ixj_PCcontrol_wait(j);
1732  return j->siadc.bits.rxg;
1733  }
1734  }
1735  return -1;
1736 }
1737 
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740  if(j->cardtype == QTI_PHONECARD){
1741  if(j->flags.pcmciascp){
1742  if(val == -1)
1743  return j->sidac.bits.txg;
1744 
1745  if(val < 0 || val > 0x1F)
1746  return -1;
1747 
1748  j->sidac.bits.srm = 1; /* Speaker Right Mute */
1749  j->sidac.bits.slm = 1; /* Speaker Left Mute */
1750  j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1751  j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1752  j->psccr.bits.rw = 0; /* Read / Write flag */
1753  j->psccr.bits.dev = 0;
1754  outb(j->sidac.byte, j->XILINXbase + 0x00);
1755  outb(j->psccr.byte, j->XILINXbase + 0x01);
1756  ixj_PCcontrol_wait(j);
1757  return j->sidac.bits.txg;
1758  }
1759  }
1760  return -1;
1761 }
1762 
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765  j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766  if (!j->flags.pcmciastate) {
1767  j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768  if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769  j->flags.pcmciastate = 4;
1770  return 0;
1771  }
1772  if (j->pccr1.bits.ed) {
1773  j->pccr1.bits.ed = 0;
1774  j->psccr.bits.dev = 3;
1775  j->psccr.bits.rw = 1;
1776  outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777  ixj_PCcontrol_wait(j);
1778  j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779  j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780  j->psccr.bits.dev = 3;
1781  j->psccr.bits.rw = 0;
1782  outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783  ixj_PCcontrol_wait(j);
1784  return j->pslic.bits.led2 ? 1 : 0;
1785  } else if (j->flags.pcmciasct) {
1786  return j->r_hook;
1787  } else {
1788  return 1;
1789  }
1790  } else if (j->flags.pcmciastate == 4) {
1791  if (!j->pccr1.bits.drf) {
1792  j->flags.pcmciastate = 3;
1793  }
1794  return 0;
1795  } else if (j->flags.pcmciastate == 3) {
1796  j->pccr2.bits.pwr = 0;
1797  j->pccr2.bits.rstc = 1;
1798  outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799  j->checkwait = jiffies + (hertz * 2);
1800  j->flags.incheck = 1;
1801  j->flags.pcmciastate = 2;
1802  return 0;
1803  } else if (j->flags.pcmciastate == 2) {
1804  if (j->flags.incheck) {
1805  if (time_before(jiffies, j->checkwait)) {
1806  return 0;
1807  } else {
1808  j->flags.incheck = 0;
1809  }
1810  }
1811  j->pccr2.bits.pwr = 0;
1812  j->pccr2.bits.rstc = 0;
1813  outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814  j->flags.pcmciastate = 1;
1815  return 0;
1816  } else if (j->flags.pcmciastate == 1) {
1817  j->flags.pcmciastate = 0;
1818  if (!j->pccr1.bits.drf) {
1819  j->psccr.bits.dev = 3;
1820  j->psccr.bits.rw = 1;
1821  outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822  ixj_PCcontrol_wait(j);
1823  j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1824 
1825  j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1826 
1827  if (j->flags.pcmciasct == 3) {
1828  j->flags.pcmciastate = 4;
1829  return 0;
1830  } else if (j->flags.pcmciasct == 0) {
1831  j->pccr2.bits.pwr = 1;
1832  j->pccr2.bits.rstc = 0;
1833  outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834  j->port = PORT_SPEAKER;
1835  } else {
1836  j->port = PORT_POTS;
1837  }
1838  j->sic1.bits.cpd = 0; /* Chip Power Down */
1839  j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1840  j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1841  j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1842  j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1843  j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1844  j->psccr.bits.rw = 0; /* Read / Write flag */
1845  j->psccr.bits.dev = 0;
1846  outb(j->sic1.byte, j->XILINXbase + 0x00);
1847  outb(j->psccr.byte, j->XILINXbase + 0x01);
1848  ixj_PCcontrol_wait(j);
1849 
1850  j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1851  j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1852  j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1853  j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1854  j->sic2.bits.hpd = 0; /* HPF disable */
1855  j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1856  j->psccr.bits.rw = 0; /* Read / Write flag */
1857  j->psccr.bits.dev = 0;
1858  outb(j->sic2.byte, j->XILINXbase + 0x00);
1859  outb(j->psccr.byte, j->XILINXbase + 0x01);
1860  ixj_PCcontrol_wait(j);
1861 
1862  j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1863  j->psccr.bits.rw = 0; /* Read / Write flag */
1864  j->psccr.bits.dev = 0;
1865  outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1866  outb(j->psccr.byte, j->XILINXbase + 0x01);
1867  ixj_PCcontrol_wait(j);
1868 
1869  j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1870  j->psccr.bits.rw = 0; /* Read / Write flag */
1871  j->psccr.bits.dev = 0;
1872  outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1873  outb(j->psccr.byte, j->XILINXbase + 0x01);
1874  ixj_PCcontrol_wait(j);
1875 
1876  j->sirxg.bits.lig = 1; /* Line In Gain */
1877  j->sirxg.bits.lim = 1; /* Line In Mute */
1878  j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1879  j->sirxg.bits.mcm = 0; /* MIC In Mute */
1880  j->sirxg.bits.him = 0; /* Handset In Mute */
1881  j->sirxg.bits.iir = 1; /* IIR */
1882  j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1883  j->psccr.bits.rw = 0; /* Read / Write flag */
1884  j->psccr.bits.dev = 0;
1885  outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886  outb(j->psccr.byte, j->XILINXbase + 0x01);
1887  ixj_PCcontrol_wait(j);
1888 
1889  ixj_siadc(j, 0x17);
1890  ixj_sidac(j, 0x1D);
1891 
1892  j->siaatt.bits.sot = 0;
1893  j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1894  j->psccr.bits.rw = 0; /* Read / Write flag */
1895  j->psccr.bits.dev = 0;
1896  outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897  outb(j->psccr.byte, j->XILINXbase + 0x01);
1898  ixj_PCcontrol_wait(j);
1899 
1900  if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901  j->psccr.byte = j->pslic.byte = 0;
1902  j->pslic.bits.powerdown = 1;
1903  j->psccr.bits.dev = 3;
1904  j->psccr.bits.rw = 0;
1905  outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906  ixj_PCcontrol_wait(j);
1907  }
1908  }
1909  return 0;
1910  } else {
1911  j->flags.pcmciascp = 0;
1912  return 0;
1913  }
1914  return 0;
1915 }
1916 
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919  int fOffHook = 0;
1920 
1921  switch (j->cardtype) {
1922  case QTI_PHONEJACK:
1923  ixj_gpio_read(j);
1924  fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925  break;
1926  case QTI_LINEJACK:
1927  case QTI_PHONEJACK_LITE:
1928  case QTI_PHONEJACK_PCI:
1929  SLIC_GetState(j);
1930  if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931  fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932  if(fOffHook != j->p_hook) {
1933  if(!j->checkwait) {
1934  j->checkwait = jiffies;
1935  }
1936  if(time_before(jiffies, j->checkwait + 2)) {
1937  fOffHook ^= 1;
1938  } else {
1939  j->checkwait = 0;
1940  }
1941  j->p_hook = fOffHook;
1942  printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943  }
1944  } else {
1945  if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946  j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947  if (j->flags.ringing || j->flags.cringing) {
1948  if (!in_interrupt()) {
1949  msleep(20);
1950  }
1951  SLIC_GetState(j);
1952  if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953  ixj_ring_on(j);
1954  }
1955  }
1956  if (j->cardtype == QTI_PHONEJACK_PCI) {
1957  j->pld_scrr.byte = inb_p(j->XILINXbase);
1958  fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959  } else
1960  fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961  }
1962  }
1963  break;
1964  case QTI_PHONECARD:
1965  fOffHook = ixj_pcmcia_cable_check(j);
1966  break;
1967  }
1968  if (j->r_hook != fOffHook) {
1969  j->r_hook = fOffHook;
1970  if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971  j->ex.bits.hookstate = 1;
1972  ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973  } else if (!fOffHook) {
1974  j->flash_end = jiffies + ((60 * hertz) / 100);
1975  }
1976  }
1977  if (fOffHook) {
1978  if(time_before(jiffies, j->flash_end)) {
1979  j->ex.bits.flash = 1;
1980  j->flash_end = 0;
1981  ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982  }
1983  } else {
1984  if(time_before(jiffies, j->flash_end)) {
1985  fOffHook = 1;
1986  }
1987  }
1988 
1989  if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990  fOffHook |= 2;
1991 
1992  if (j->port == PORT_SPEAKER) {
1993  if(j->cardtype == QTI_PHONECARD) {
1994  if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995  fOffHook |= 2;
1996  }
1997  } else {
1998  fOffHook |= 2;
1999  }
2000  }
2001 
2002  if (j->port == PORT_HANDSET)
2003  fOffHook |= 2;
2004 
2005  return fOffHook;
2006 }
2007 
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010  if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011  {
2012  if (ixjdebug & 0x0004)
2013  printk(KERN_INFO "IXJ Ring Off\n");
2014  j->gpio.bytes.high = 0x0B;
2015  j->gpio.bytes.low = 0x00;
2016  j->gpio.bits.gpio1 = 0;
2017  j->gpio.bits.gpio2 = 1;
2018  j->gpio.bits.gpio5 = 0;
2019  ixj_WriteDSPCommand(j->gpio.word, j);
2020  } else /* Internet LineJACK */
2021  {
2022  if (ixjdebug & 0x0004)
2023  printk(KERN_INFO "IXJ Ring Off\n");
2024 
2025  if(!j->flags.cidplay)
2026  SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027 
2028  SLIC_GetState(j);
2029  }
2030 }
2031 
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034  j->flags.cringing = 1;
2035  if (ixjdebug & 0x0004)
2036  printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037  if (ixj_hookstate(j) & 1) {
2038  if (j->port == PORT_POTS)
2039  ixj_ring_off(j);
2040  j->flags.cringing = 0;
2041  if (ixjdebug & 0x0004)
2042  printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043  } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044  j->ring_cadence_jif = jiffies;
2045  j->flags.cidsent = j->flags.cidring = 0;
2046  j->cadence_f[5].state = 0;
2047  if(j->cadence_f[5].on1)
2048  ixj_ring_on(j);
2049  } else {
2050  j->ring_cadence_jif = jiffies;
2051  j->ring_cadence_t = 15;
2052  if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053  ixj_ring_on(j);
2054  } else {
2055  ixj_ring_off(j);
2056  }
2057  j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058  }
2059 }
2060 
2061 static int ixj_ring(IXJ *j)
2062 {
2063  char cntr;
2064  unsigned long jif;
2065 
2066  j->flags.ringing = 1;
2067  if (ixj_hookstate(j) & 1) {
2068  ixj_ring_off(j);
2069  j->flags.ringing = 0;
2070  return 1;
2071  }
2072  for (cntr = 0; cntr < j->maxrings; cntr++) {
2073  jif = jiffies + (1 * hertz);
2074  ixj_ring_on(j);
2075  while (time_before(jiffies, jif)) {
2076  if (ixj_hookstate(j) & 1) {
2077  ixj_ring_off(j);
2078  j->flags.ringing = 0;
2079  return 1;
2080  }
2081  schedule_timeout_interruptible(1);
2082  if (signal_pending(current))
2083  break;
2084  }
2085  jif = jiffies + (3 * hertz);
2086  ixj_ring_off(j);
2087  while (time_before(jiffies, jif)) {
2088  if (ixj_hookstate(j) & 1) {
2089  msleep(10);
2090  if (ixj_hookstate(j) & 1) {
2091  j->flags.ringing = 0;
2092  return 1;
2093  }
2094  }
2095  schedule_timeout_interruptible(1);
2096  if (signal_pending(current))
2097  break;
2098  }
2099  }
2100  ixj_ring_off(j);
2101  j->flags.ringing = 0;
2102  return 0;
2103 }
2104 
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107  IXJ *j = get_ixj(p->board);
2108  file_p->private_data = j;
2109 
2110  if (!j->DSPbase)
2111  return -ENODEV;
2112 
2113  if (file_p->f_mode & FMODE_READ) {
2114  if(!j->readers) {
2115  j->readers++;
2116  } else {
2117  return -EBUSY;
2118  }
2119  }
2120 
2121  if (file_p->f_mode & FMODE_WRITE) {
2122  if(!j->writers) {
2123  j->writers++;
2124  } else {
2125  if (file_p->f_mode & FMODE_READ){
2126  j->readers--;
2127  }
2128  return -EBUSY;
2129  }
2130  }
2131 
2132  if (j->cardtype == QTI_PHONECARD) {
2133  j->pslic.bits.powerdown = 0;
2134  j->psccr.bits.dev = 3;
2135  j->psccr.bits.rw = 0;
2136  outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137  ixj_PCcontrol_wait(j);
2138  }
2139 
2140  j->flags.cidplay = 0;
2141  j->flags.cidcw_ack = 0;
2142 
2143  if (ixjdebug & 0x0002)
2144  printk(KERN_INFO "Opening board %d\n", p->board);
2145 
2146  j->framesread = j->frameswritten = 0;
2147  return 0;
2148 }
2149 
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152  IXJ_TONE ti;
2153  int cnt;
2154  IXJ *j = file_p->private_data;
2155  int board = j->p.board;
2156 
2157  /*
2158  * Set up locks to ensure that only one process is talking to the DSP at a time.
2159  * This is necessary to keep the DSP from locking up.
2160  */
2161  while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162  schedule_timeout_interruptible(1);
2163  if (ixjdebug & 0x0002)
2164  printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165 
2166  if (j->cardtype == QTI_PHONECARD)
2167  ixj_set_port(j, PORT_SPEAKER);
2168  else
2169  ixj_set_port(j, PORT_POTS);
2170 
2171  aec_stop(j);
2172  ixj_play_stop(j);
2173  ixj_record_stop(j);
2174  set_play_volume(j, 0x100);
2175  set_rec_volume(j, 0x100);
2176  ixj_ring_off(j);
2177 
2178  /* Restore the tone table to default settings. */
2179  ti.tone_index = 10;
2180  ti.gain0 = 1;
2181  ti.freq0 = hz941;
2182  ti.gain1 = 0;
2183  ti.freq1 = hz1209;
2184  ixj_init_tone(j, &ti);
2185  ti.tone_index = 11;
2186  ti.gain0 = 1;
2187  ti.freq0 = hz941;
2188  ti.gain1 = 0;
2189  ti.freq1 = hz1336;
2190  ixj_init_tone(j, &ti);
2191  ti.tone_index = 12;
2192  ti.gain0 = 1;
2193  ti.freq0 = hz941;
2194  ti.gain1 = 0;
2195  ti.freq1 = hz1477;
2196  ixj_init_tone(j, &ti);
2197  ti.tone_index = 13;
2198  ti.gain0 = 1;
2199  ti.freq0 = hz800;
2200  ti.gain1 = 0;
2201  ti.freq1 = 0;
2202  ixj_init_tone(j, &ti);
2203  ti.tone_index = 14;
2204  ti.gain0 = 1;
2205  ti.freq0 = hz1000;
2206  ti.gain1 = 0;
2207  ti.freq1 = 0;
2208  ixj_init_tone(j, &ti);
2209  ti.tone_index = 15;
2210  ti.gain0 = 1;
2211  ti.freq0 = hz1250;
2212  ti.gain1 = 0;
2213  ti.freq1 = 0;
2214  ixj_init_tone(j, &ti);
2215  ti.tone_index = 16;
2216  ti.gain0 = 1;
2217  ti.freq0 = hz950;
2218  ti.gain1 = 0;
2219  ti.freq1 = 0;
2220  ixj_init_tone(j, &ti);
2221  ti.tone_index = 17;
2222  ti.gain0 = 1;
2223  ti.freq0 = hz1100;
2224  ti.gain1 = 0;
2225  ti.freq1 = 0;
2226  ixj_init_tone(j, &ti);
2227  ti.tone_index = 18;
2228  ti.gain0 = 1;
2229  ti.freq0 = hz1400;
2230  ti.gain1 = 0;
2231  ti.freq1 = 0;
2232  ixj_init_tone(j, &ti);
2233  ti.tone_index = 19;
2234  ti.gain0 = 1;
2235  ti.freq0 = hz1500;
2236  ti.gain1 = 0;
2237  ti.freq1 = 0;
2238  ixj_init_tone(j, &ti);
2239  ti.tone_index = 20;
2240  ti.gain0 = 1;
2241  ti.freq0 = hz1600;
2242  ti.gain1 = 0;
2243  ti.freq1 = 0;
2244  ixj_init_tone(j, &ti);
2245  ti.tone_index = 21;
2246  ti.gain0 = 1;
2247  ti.freq0 = hz1800;
2248  ti.gain1 = 0;
2249  ti.freq1 = 0;
2250  ixj_init_tone(j, &ti);
2251  ti.tone_index = 22;
2252  ti.gain0 = 1;
2253  ti.freq0 = hz2100;
2254  ti.gain1 = 0;
2255  ti.freq1 = 0;
2256  ixj_init_tone(j, &ti);
2257  ti.tone_index = 23;
2258  ti.gain0 = 1;
2259  ti.freq0 = hz1300;
2260  ti.gain1 = 0;
2261  ti.freq1 = 0;
2262  ixj_init_tone(j, &ti);
2263  ti.tone_index = 24;
2264  ti.gain0 = 1;
2265  ti.freq0 = hz2450;
2266  ti.gain1 = 0;
2267  ti.freq1 = 0;
2268  ixj_init_tone(j, &ti);
2269  ti.tone_index = 25;
2270  ti.gain0 = 1;
2271  ti.freq0 = hz350;
2272  ti.gain1 = 0;
2273  ti.freq1 = hz440;
2274  ixj_init_tone(j, &ti);
2275  ti.tone_index = 26;
2276  ti.gain0 = 1;
2277  ti.freq0 = hz440;
2278  ti.gain1 = 0;
2279  ti.freq1 = hz480;
2280  ixj_init_tone(j, &ti);
2281  ti.tone_index = 27;
2282  ti.gain0 = 1;
2283  ti.freq0 = hz480;
2284  ti.gain1 = 0;
2285  ti.freq1 = hz620;
2286  ixj_init_tone(j, &ti);
2287 
2288  set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2289 
2290  set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2291 
2292  j->ex.bits.dtmf_ready = 0;
2293  j->dtmf_state = 0;
2294  j->dtmf_wp = j->dtmf_rp = 0;
2295  j->rec_mode = j->play_mode = -1;
2296  j->flags.ringing = 0;
2297  j->maxrings = MAXRINGS;
2298  j->ring_cadence = USA_RING_CADENCE;
2299  if(j->cadence_f[5].enable) {
2300  j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301  }
2302  j->drybuffer = 0;
2303  j->winktime = 320;
2304  j->flags.dtmf_oob = 0;
2305  for (cnt = 0; cnt < 4; cnt++)
2306  j->cadence_f[cnt].enable = 0;
2307 
2308  idle(j);
2309 
2310  if(j->cardtype == QTI_PHONECARD) {
2311  SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312  }
2313 
2314  if (file_p->f_mode & FMODE_READ)
2315  j->readers--;
2316  if (file_p->f_mode & FMODE_WRITE)
2317  j->writers--;
2318 
2319  if (j->read_buffer && !j->readers) {
2320  kfree(j->read_buffer);
2321  j->read_buffer = NULL;
2322  j->read_buffer_size = 0;
2323  }
2324  if (j->write_buffer && !j->writers) {
2325  kfree(j->write_buffer);
2326  j->write_buffer = NULL;
2327  j->write_buffer_size = 0;
2328  }
2329  j->rec_codec = j->play_codec = 0;
2330  j->rec_frame_size = j->play_frame_size = 0;
2331  j->flags.cidsent = j->flags.cidring = 0;
2332 
2333  if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334  ixj_set_port(j, PORT_PSTN);
2335  daa_set_mode(j, SOP_PU_SLEEP);
2336  ixj_set_pots(j, 1);
2337  }
2338  ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339 
2340  /* Set up the default signals for events */
2341  for (cnt = 0; cnt < 35; cnt++)
2342  j->ixj_signals[cnt] = SIGIO;
2343 
2344  /* Set the excetion signal enable flags */
2345  j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346  j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347  j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348 
2349  file_p->private_data = NULL;
2350  clear_bit(board, &j->busyflags);
2351  return 0;
2352 }
2353 
2354 static int read_filters(IXJ *j)
2355 {
2356  unsigned short fc, cnt, trg;
2357  int var;
2358 
2359  trg = 0;
2360  if (ixj_WriteDSPCommand(0x5144, j)) {
2361  if(ixjdebug & 0x0001) {
2362  printk(KERN_INFO "Read Frame Counter failed!\n");
2363  }
2364  return -1;
2365  }
2366  fc = j->ssr.high << 8 | j->ssr.low;
2367  if (fc == j->frame_count)
2368  return 1;
2369 
2370  j->frame_count = fc;
2371 
2372  if (j->dtmf_proc)
2373  return 1;
2374 
2375  var = 10;
2376 
2377  for (cnt = 0; cnt < 4; cnt++) {
2378  if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379  if(ixjdebug & 0x0001) {
2380  printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381  }
2382  return -1;
2383  }
2384  if (ixj_WriteDSPCommand(0x515C, j)) {
2385  if(ixjdebug & 0x0001) {
2386  printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387  }
2388  return -1;
2389  }
2390  j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391 
2392  if (j->cadence_f[cnt].enable) {
2393  if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394  if (j->cadence_f[cnt].state == 0) {
2395  j->cadence_f[cnt].state = 1;
2396  j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397  j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398  j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399  } else if (j->cadence_f[cnt].state == 2 &&
2400  (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401  time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402  if (j->cadence_f[cnt].on2) {
2403  j->cadence_f[cnt].state = 3;
2404  j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405  j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406  j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407  } else {
2408  j->cadence_f[cnt].state = 7;
2409  }
2410  } else if (j->cadence_f[cnt].state == 4 &&
2411  (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412  time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413  if (j->cadence_f[cnt].on3) {
2414  j->cadence_f[cnt].state = 5;
2415  j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416  j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417  j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418  } else {
2419  j->cadence_f[cnt].state = 7;
2420  }
2421  } else {
2422  j->cadence_f[cnt].state = 0;
2423  }
2424  } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425  if (j->cadence_f[cnt].state == 1) {
2426  if(!j->cadence_f[cnt].on1) {
2427  j->cadence_f[cnt].state = 7;
2428  } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429  time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430  if(j->cadence_f[cnt].off1) {
2431  j->cadence_f[cnt].state = 2;
2432  j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433  j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434  j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435  } else {
2436  j->cadence_f[cnt].state = 7;
2437  }
2438  } else {
2439  j->cadence_f[cnt].state = 0;
2440  }
2441  } else if (j->cadence_f[cnt].state == 3) {
2442  if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443  time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444  if(j->cadence_f[cnt].off2) {
2445  j->cadence_f[cnt].state = 4;
2446  j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447  j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448  j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449  } else {
2450  j->cadence_f[cnt].state = 7;
2451  }
2452  } else {
2453  j->cadence_f[cnt].state = 0;
2454  }
2455  } else if (j->cadence_f[cnt].state == 5) {
2456  if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457  time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458  if(j->cadence_f[cnt].off3) {
2459  j->cadence_f[cnt].state = 6;
2460  j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461  j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462  j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463  } else {
2464  j->cadence_f[cnt].state = 7;
2465  }
2466  } else {
2467  j->cadence_f[cnt].state = 0;
2468  }
2469  } else {
2470  j->cadence_f[cnt].state = 0;
2471  }
2472  } else {
2473  switch(j->cadence_f[cnt].state) {
2474  case 1:
2475  if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476  !j->cadence_f[cnt].off1 &&
2477  !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478  !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479  j->cadence_f[cnt].state = 7;
2480  }
2481  break;
2482  case 3:
2483  if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484  !j->cadence_f[cnt].off2 &&
2485  !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486  j->cadence_f[cnt].state = 7;
2487  }
2488  break;
2489  case 5:
2490  if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491  !j->cadence_f[cnt].off3) {
2492  j->cadence_f[cnt].state = 7;
2493  }
2494  break;
2495  }
2496  }
2497 
2498  if (ixjdebug & 0x0040) {
2499  printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500  switch(j->cadence_f[cnt].state) {
2501  case 0:
2502  printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503  break;
2504  case 1:
2505  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506  j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507  break;
2508  case 2:
2509  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510  j->cadence_f[cnt].off1max);
2511  break;
2512  case 3:
2513  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514  j->cadence_f[cnt].on2max);
2515  break;
2516  case 4:
2517  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518  j->cadence_f[cnt].off2max);
2519  break;
2520  case 5:
2521  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522  j->cadence_f[cnt].on3max);
2523  break;
2524  case 6:
2525  printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526  j->cadence_f[cnt].off3max);
2527  break;
2528  }
2529  }
2530  }
2531  if (j->cadence_f[cnt].state == 7) {
2532  j->cadence_f[cnt].state = 0;
2533  if (j->cadence_f[cnt].enable == 1)
2534  j->cadence_f[cnt].enable = 0;
2535  switch (cnt) {
2536  case 0:
2537  if(ixjdebug & 0x0020) {
2538  printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539  }
2540  j->ex.bits.fc0 = 1;
2541  ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542  break;
2543  case 1:
2544  if(ixjdebug & 0x0020) {
2545  printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546  }
2547  j->ex.bits.fc1 = 1;
2548  ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549  break;
2550  case 2:
2551  if(ixjdebug & 0x0020) {
2552  printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553  }
2554  j->ex.bits.fc2 = 1;
2555  ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556  break;
2557  case 3:
2558  if(ixjdebug & 0x0020) {
2559  printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560  }
2561  j->ex.bits.fc3 = 1;
2562  ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563  break;
2564  }
2565  }
2566  if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567  (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568  if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569  trg = 1;
2570  } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571  trg = 0;
2572  }
2573  switch (cnt) {
2574  case 0:
2575  if(ixjdebug & 0x0020) {
2576  printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577  }
2578  j->ex.bits.f0 = 1;
2579  ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580  break;
2581  case 1:
2582  if(ixjdebug & 0x0020) {
2583  printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584  }
2585  j->ex.bits.f1 = 1;
2586  ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587  break;
2588  case 2:
2589  if(ixjdebug & 0x0020) {
2590  printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591  }
2592  j->ex.bits.f2 = 1;
2593  ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594  break;
2595  case 3:
2596  if(ixjdebug & 0x0020) {
2597  printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598  }
2599  j->ex.bits.f3 = 1;
2600  ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601  break;
2602  }
2603  }
2604  }
2605  return 0;
2606 }
2607 
2608 static int LineMonitor(IXJ *j)
2609 {
2610  if (j->dtmf_proc) {
2611  return -1;
2612  }
2613  j->dtmf_proc = 1;
2614 
2615  if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2616  return -1;
2617 
2618  j->dtmf.bytes.high = j->ssr.high;
2619  j->dtmf.bytes.low = j->ssr.low;
2620  if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621  j->dtmf_state = 1;
2622  j->dtmf_current = j->dtmf.bits.digit;
2623  }
2624  if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2625  {
2626  if(!j->cidcw_wait) {
2627  j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628  j->dtmf_wp++;
2629  if (j->dtmf_wp == 79)
2630  j->dtmf_wp = 0;
2631  j->ex.bits.dtmf_ready = 1;
2632  if(j->ex_sig.bits.dtmf_ready) {
2633  ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634  }
2635  }
2636  else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637  if(ixjdebug & 0x0020) {
2638  printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639  }
2640  j->flags.cidcw_ack = 1;
2641  }
2642  j->dtmf_state = 0;
2643  }
2644  j->dtmf_proc = 0;
2645 
2646  return 0;
2647 }
2648 
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654 
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657  static unsigned char table_ulaw2alaw[] =
2658  {
2659  0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660  0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661  0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662  0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663  0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664  0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665  0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666  0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667  0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668  0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669  0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670  0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671  0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672  0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673  0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674  0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675  0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676  0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677  0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678  0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679  0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680  0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681  0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682  0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683  0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684  0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685  0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686  0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687  0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688  0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689  0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690  0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691  };
2692 
2693  while (len--)
2694  {
2695  *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696  buff++;
2697  }
2698 }
2699 
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702  static unsigned char table_alaw2ulaw[] =
2703  {
2704  0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705  0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706  0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707  0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708  0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709  0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710  0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711  0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712  0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713  0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714  0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715  0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716  0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717  0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718  0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719  0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720  0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721  0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722  0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723  0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724  0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725  0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726  0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727  0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728  0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729  0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730  0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731  0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732  0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733  0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734  0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735  0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736  };
2737 
2738  while (len--)
2739  {
2740  *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741  buff++;
2742  }
2743 }
2744 
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747  unsigned long i = *ppos;
2748  IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749 
2750  DECLARE_WAITQUEUE(wait, current);
2751 
2752  if (j->flags.inread)
2753  return -EALREADY;
2754 
2755  j->flags.inread = 1;
2756 
2757  add_wait_queue(&j->read_q, &wait);
2758  set_current_state(TASK_INTERRUPTIBLE);
2759  mb();
2760 
2761  while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762  ++j->read_wait;
2763  if (file_p->f_flags & O_NONBLOCK) {
2764  set_current_state(TASK_RUNNING);
2765  remove_wait_queue(&j->read_q, &wait);
2766  j->flags.inread = 0;
2767  return -EAGAIN;
2768  }
2769  if (!ixj_hookstate(j)) {
2770  set_current_state(TASK_RUNNING);
2771  remove_wait_queue(&j->read_q, &wait);
2772  j->flags.inread = 0;
2773  return 0;
2774  }
2775  interruptible_sleep_on(&j->read_q);
2776  if (signal_pending(current)) {
2777  set_current_state(TASK_RUNNING);
2778  remove_wait_queue(&j->read_q, &wait);
2779  j->flags.inread = 0;
2780  return -EINTR;
2781  }
2782  }
2783 
2784  remove_wait_queue(&j->read_q, &wait);
2785  set_current_state(TASK_RUNNING);
2786  /* Don't ever copy more than the user asks */
2787  if(j->rec_codec == ALAW)
2788  ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789  i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790  j->read_buffer_ready = 0;
2791  if (i) {
2792  j->flags.inread = 0;
2793  return -EFAULT;
2794  } else {
2795  j->flags.inread = 0;
2796  return min(length, j->read_buffer_size);
2797  }
2798 }
2799 
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801  loff_t * ppos)
2802 {
2803  int pre_retval;
2804  ssize_t read_retval = 0;
2805  IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806 
2807  pre_retval = ixj_PreRead(j, 0L);
2808  switch (pre_retval) {
2809  case NORMAL:
2810  read_retval = ixj_read(file_p, buf, length, ppos);
2811  ixj_PostRead(j, 0L);
2812  break;
2813  case NOPOST:
2814  read_retval = ixj_read(file_p, buf, length, ppos);
2815  break;
2816  case POSTONLY:
2817  ixj_PostRead(j, 0L);
2818  break;
2819  default:
2820  read_retval = pre_retval;
2821  }
2822  return read_retval;
2823 }
2824 
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827  unsigned long i = *ppos;
2828  IXJ *j = file_p->private_data;
2829 
2830  DECLARE_WAITQUEUE(wait, current);
2831 
2832  if (j->flags.inwrite)
2833  return -EALREADY;
2834 
2835  j->flags.inwrite = 1;
2836 
2837  add_wait_queue(&j->write_q, &wait);
2838  set_current_state(TASK_INTERRUPTIBLE);
2839  mb();
2840 
2841 
2842  while (!j->write_buffers_empty) {
2843  ++j->write_wait;
2844  if (file_p->f_flags & O_NONBLOCK) {
2845  set_current_state(TASK_RUNNING);
2846  remove_wait_queue(&j->write_q, &wait);
2847  j->flags.inwrite = 0;
2848  return -EAGAIN;
2849  }
2850  if (!ixj_hookstate(j)) {
2851  set_current_state(TASK_RUNNING);
2852  remove_wait_queue(&j->write_q, &wait);
2853  j->flags.inwrite = 0;
2854  return 0;
2855  }
2856  interruptible_sleep_on(&j->write_q);
2857  if (signal_pending(current)) {
2858  set_current_state(TASK_RUNNING);
2859  remove_wait_queue(&j->write_q, &wait);
2860  j->flags.inwrite = 0;
2861  return -EINTR;
2862  }
2863  }
2864  set_current_state(TASK_RUNNING);
2865  remove_wait_queue(&j->write_q, &wait);
2866  if (j->write_buffer_wp + count >= j->write_buffer_end)
2867  j->write_buffer_wp = j->write_buffer;
2868  i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869  if (i) {
2870  j->flags.inwrite = 0;
2871  return -EFAULT;
2872  }
2873  if(j->play_codec == ALAW)
2874  alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875  j->flags.inwrite = 0;
2876  return min(count, j->write_buffer_size);
2877 }
2878 
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881  int pre_retval;
2882  ssize_t write_retval = 0;
2883 
2884  IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885 
2886  pre_retval = ixj_PreWrite(j, 0L);
2887  switch (pre_retval) {
2888  case NORMAL:
2889  write_retval = ixj_write(file_p, buf, count, ppos);
2890  if (write_retval > 0) {
2891  ixj_PostWrite(j, 0L);
2892  j->write_buffer_wp += write_retval;
2893  j->write_buffers_empty--;
2894  }
2895  break;
2896  case NOPOST:
2897  write_retval = ixj_write(file_p, buf, count, ppos);
2898  if (write_retval > 0) {
2899  j->write_buffer_wp += write_retval;
2900  j->write_buffers_empty--;
2901  }
2902  break;
2903  case POSTONLY:
2904  ixj_PostWrite(j, 0L);
2905  break;
2906  default:
2907  write_retval = pre_retval;
2908  }
2909  return write_retval;
2910 }
2911 
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914  int cnt, dly;
2915 
2916  if (j->read_buffer) {
2917  for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918  if (!(cnt % 16) && !IsRxReady(j)) {
2919  dly = 0;
2920  while (!IsRxReady(j)) {
2921  if (dly++ > 5) {
2922  dly = 0;
2923  break;
2924  }
2925  udelay(10);
2926  }
2927  }
2928  /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929  if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930  inb_p(j->DSPbase + 0x0E);
2931  inb_p(j->DSPbase + 0x0F);
2932  }
2933  *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934  *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935  }
2936  ++j->framesread;
2937  if (j->intercom != -1) {
2938  if (IsTxReady(get_ixj(j->intercom))) {
2939  for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940  if (!(cnt % 16) && !IsTxReady(j)) {
2941  dly = 0;
2942  while (!IsTxReady(j)) {
2943  if (dly++ > 5) {
2944  dly = 0;
2945  break;
2946  }
2947  udelay(10);
2948  }
2949  }
2950  outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951  outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952  }
2953  get_ixj(j->intercom)->frameswritten++;
2954  }
2955  } else {
2956  j->read_buffer_ready = 1;
2957  wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2958 
2959  wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2960 
2961  if(j->ixj_signals[SIG_READ_READY])
2962  ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963  }
2964  }
2965 }
2966 
2967 static short fsk[][6][20] =
2968 {
2969  {
2970  {
2971  0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972  -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973  },
2974  {
2975  -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976  -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977  },
2978  {
2979  -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980  -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981  },
2982  {
2983  0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984  16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985  },
2986  {
2987  28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988  32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989  },
2990  {
2991  28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992  16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993  }
2994  },
2995  {
2996  {
2997  0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998  0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999  },
3000  {
3001  -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002  28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003  },
3004  {
3005  -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006  28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007  },
3008  {
3009  0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010  0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011  },
3012  {
3013  28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014  -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015  },
3016  {
3017  28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018  -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019  }
3020  }
3021 };
3022 
3023 
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026  while (j->fskcnt < 20) {
3027  if(j->fskdcnt < (j->fsksize - 1))
3028  j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029 
3030  j->fskcnt += 3;
3031  }
3032  j->fskcnt %= 20;
3033 
3034  if (!bit)
3035  j->fskz++;
3036  if (j->fskz >= 6)
3037  j->fskz = 0;
3038 
3039 }
3040 
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043  IXJ_CBYTE cb;
3044 
3045  cb.cbyte = byte;
3046  ixj_write_cid_bit(j, 0);
3047  ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048  ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049  ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050  ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051  ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052  ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053  ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054  ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055  ixj_write_cid_bit(j, 1);
3056 }
3057 
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060  int cnt;
3061 
3062  for (cnt = 0; cnt < 150; cnt++) {
3063  ixj_write_cid_bit(j, 0);
3064  ixj_write_cid_bit(j, 1);
3065  }
3066  for (cnt = 0; cnt < 180; cnt++) {
3067  ixj_write_cid_bit(j, 1);
3068  }
3069 }
3070 
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073  int cnt;
3074 
3075  for (cnt = 0; cnt < 80; cnt++) {
3076  ixj_write_cid_bit(j, 1);
3077  }
3078 }
3079 
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082  int cnt;
3083 
3084  for (cnt = 0; cnt < strlen(s); cnt++) {
3085  ixj_write_cid_byte(j, s[cnt]);
3086  checksum = (checksum + s[cnt]);
3087  }
3088  return checksum;
3089 }
3090 
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093  int cnt;
3094 
3095  for (cnt = 0; cnt < pad; cnt++) {
3096  if(j->fskdcnt < (j->fsksize - 1))
3097  j->fskdata[j->fskdcnt++] = 0x0000;
3098  }
3099  for (cnt = 0; cnt < 720; cnt++) {
3100  if(j->fskdcnt < (j->fsksize - 1))
3101  j->fskdata[j->fskdcnt++] = 0x0000;
3102  }
3103 }
3104 
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107  j->cid_play_codec = j->play_codec;
3108  j->cid_play_frame_size = j->play_frame_size;
3109  j->cid_play_volume = get_play_volume(j);
3110  j->cid_play_flag = j->flags.playing;
3111 
3112  j->cid_rec_codec = j->rec_codec;
3113  j->cid_rec_volume = get_rec_volume(j);
3114  j->cid_rec_flag = j->flags.recording;
3115 
3116  j->cid_play_aec_level = j->aec_level;
3117 
3118  switch(j->baseframe.low) {
3119  case 0xA0:
3120  j->cid_base_frame_size = 20;
3121  break;
3122  case 0x50:
3123  j->cid_base_frame_size = 10;
3124  break;
3125  case 0xF0:
3126  j->cid_base_frame_size = 30;
3127  break;
3128  }
3129 
3130  ixj_play_stop(j);
3131  ixj_cpt_stop(j);
3132 
3133  j->flags.cidplay = 1;
3134 
3135  set_base_frame(j, 30);
3136  set_play_codec(j, LINEAR16);
3137  set_play_volume(j, 0x1B);
3138  ixj_play_start(j);
3139 }
3140 
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143  ixj_play_stop(j);
3144 
3145  if(j->cidsize > 5000) {
3146  SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147  }
3148  j->flags.cidplay = 0;
3149  if(ixjdebug & 0x0200) {
3150  printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151  }
3152 
3153  ixj_fsk_free(j);
3154 
3155  j->fskdcnt = 0;
3156  set_base_frame(j, j->cid_base_frame_size);
3157  set_play_codec(j, j->cid_play_codec);
3158  ixj_aec_start(j, j->cid_play_aec_level);
3159  set_play_volume(j, j->cid_play_volume);
3160 
3161  set_rec_codec(j, j->cid_rec_codec);
3162  set_rec_volume(j, j->cid_rec_volume);
3163 
3164  if(j->cid_rec_flag)
3165  ixj_record_start(j);
3166 
3167  if(j->cid_play_flag)
3168  ixj_play_start(j);
3169 
3170  if(j->cid_play_flag) {
3171  wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3172  }
3173 }
3174 
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177  char sdmf1[50];
3178  char sdmf2[50];
3179  char sdmf3[80];
3180  char mdmflen, len1, len2, len3;
3181  int pad;
3182 
3183  int checksum = 0;
3184 
3185  if (j->dsp.low == 0x20 || j->flags.cidplay)
3186  return;
3187 
3188  j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189  j->cidsize = j->cidcnt = 0;
3190 
3191  ixj_fsk_alloc(j);
3192 
3193  strlcpy(sdmf1, j->cid_send.month, sizeof(sdmf1));
3194  strlcat(sdmf1, j->cid_send.day, sizeof(sdmf1));
3195  strlcat(sdmf1, j->cid_send.hour, sizeof(sdmf1));
3196  strlcat(sdmf1, j->cid_send.min, sizeof(sdmf1));
3197  strlcpy(sdmf2, j->cid_send.number, sizeof(sdmf2));
3198  strlcpy(sdmf3, j->cid_send.name, sizeof(sdmf3));
3199 
3200  len1 = strlen(sdmf1);
3201  len2 = strlen(sdmf2);
3202  len3 = strlen(sdmf3);
3203  mdmflen = len1 + len2 + len3 + 6;
3204 
3205  while(1){
3206  ixj_write_cid_seize(j);
3207 
3208  ixj_write_cid_byte(j, 0x80);
3209  checksum = 0x80;
3210  ixj_write_cid_byte(j, mdmflen);
3211  checksum = checksum + mdmflen;
3212 
3213  ixj_write_cid_byte(j, 0x01);
3214  checksum = checksum + 0x01;
3215  ixj_write_cid_byte(j, len1);
3216  checksum = checksum + len1;
3217  checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218  if(ixj_hookstate(j) & 1)
3219  break;
3220 
3221  ixj_write_cid_byte(j, 0x02);
3222  checksum = checksum + 0x02;
3223  ixj_write_cid_byte(j, len2);
3224  checksum = checksum + len2;
3225  checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226  if(ixj_hookstate(j) & 1)
3227  break;
3228 
3229  ixj_write_cid_byte(j, 0x07);
3230  checksum = checksum + 0x07;
3231  ixj_write_cid_byte(j, len3);
3232  checksum = checksum + len3;
3233  checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234  if(ixj_hookstate(j) & 1)
3235  break;
3236 
3237  checksum %= 256;
3238  checksum ^= 0xFF;
3239  checksum += 1;
3240 
3241  ixj_write_cid_byte(j, (char) checksum);
3242 
3243  pad = j->fskdcnt % 240;
3244  if (pad) {
3245  pad = 240 - pad;
3246  }
3247  ixj_pad_fsk(j, pad);
3248  break;
3249  }
3250 
3251  ixj_write_frame(j);
3252 }
3253 
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256  IXJ_TONE ti;
3257 
3258  char sdmf1[50];
3259  char sdmf2[50];
3260  char sdmf3[80];
3261  char mdmflen, len1, len2, len3;
3262  int pad;
3263 
3264  int checksum = 0;
3265 
3266  if (j->dsp.low == 0x20 || j->flags.cidplay)
3267  return;
3268 
3269  j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270  j->cidsize = j->cidcnt = 0;
3271 
3272  ixj_fsk_alloc(j);
3273 
3274  j->flags.cidcw_ack = 0;
3275 
3276  ti.tone_index = 23;
3277  ti.gain0 = 1;
3278  ti.freq0 = hz440;
3279  ti.gain1 = 0;
3280  ti.freq1 = 0;
3281  ixj_init_tone(j, &ti);
3282 
3283  ixj_set_tone_on(1500, j);
3284  ixj_set_tone_off(32, j);
3285  if(ixjdebug & 0x0200) {
3286  printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287  }
3288  ixj_play_tone(j, 23);
3289 
3290  clear_bit(j->board, &j->busyflags);
3291  while(j->tone_state)
3292  schedule_timeout_interruptible(1);
3293  while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294  schedule_timeout_interruptible(1);
3295  if(ixjdebug & 0x0200) {
3296  printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297  }
3298 
3299  ti.tone_index = 24;
3300  ti.gain0 = 1;
3301  ti.freq0 = hz2130;
3302  ti.gain1 = 0;
3303  ti.freq1 = hz2750;
3304  ixj_init_tone(j, &ti);
3305 
3306  ixj_set_tone_off(10, j);
3307  ixj_set_tone_on(600, j);
3308  if(ixjdebug & 0x0200) {
3309  printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310  }
3311  ixj_play_tone(j, 24);
3312 
3313  clear_bit(j->board, &j->busyflags);
3314  while(j->tone_state)
3315  schedule_timeout_interruptible(1);
3316  while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317  schedule_timeout_interruptible(1);
3318  if(ixjdebug & 0x0200) {
3319  printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320  }
3321 
3322  j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323 
3324  clear_bit(j->board, &j->busyflags);
3325  while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326  schedule_timeout_interruptible(1);
3327  while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328  schedule_timeout_interruptible(1);
3329  j->cidcw_wait = 0;
3330  if(!j->flags.cidcw_ack) {
3331  if(ixjdebug & 0x0200) {
3332  printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333  }
3334  ixj_post_cid(j);
3335  if(j->cid_play_flag) {
3336  wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3337  }
3338  return;
3339  } else {
3340  ixj_pre_cid(j);
3341  }
3342  j->flags.cidcw_ack = 0;
3343  strlcpy(sdmf1, j->cid_send.month, sizeof(sdmf1));
3344  strlcat(sdmf1, j->cid_send.day, sizeof(sdmf1));
3345  strlcat(sdmf1, j->cid_send.hour, sizeof(sdmf1));
3346  strlcat(sdmf1, j->cid_send.min, sizeof(sdmf1));
3347  strlcpy(sdmf2, j->cid_send.number, sizeof(sdmf2));
3348  strlcpy(sdmf3, j->cid_send.name, sizeof(sdmf3));
3349 
3350  len1 = strlen(sdmf1);
3351  len2 = strlen(sdmf2);
3352  len3 = strlen(sdmf3);
3353  mdmflen = len1 + len2 + len3 + 6;
3354 
3355  ixj_write_cidcw_seize(j);
3356 
3357  ixj_write_cid_byte(j, 0x80);
3358  checksum = 0x80;
3359  ixj_write_cid_byte(j, mdmflen);
3360  checksum = checksum + mdmflen;
3361 
3362  ixj_write_cid_byte(j, 0x01);
3363  checksum = checksum + 0x01;
3364  ixj_write_cid_byte(j, len1);
3365  checksum = checksum + len1;
3366  checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367 
3368  ixj_write_cid_byte(j, 0x02);
3369  checksum = checksum + 0x02;
3370  ixj_write_cid_byte(j, len2);
3371  checksum = checksum + len2;
3372  checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373 
3374  ixj_write_cid_byte(j, 0x07);
3375  checksum = checksum + 0x07;
3376  ixj_write_cid_byte(j, len3);
3377  checksum = checksum + len3;
3378  checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379 
3380  checksum %= 256;
3381  checksum ^= 0xFF;
3382  checksum += 1;
3383 
3384  ixj_write_cid_byte(j, (char) checksum);
3385 
3386  pad = j->fskdcnt % 240;
3387  if (pad) {
3388  pad = 240 - pad;
3389  }
3390  ixj_pad_fsk(j, pad);
3391  if(ixjdebug & 0x0200) {
3392  printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393  }
3394 }
3395 
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398  char mdmflen;
3399  int pad;
3400 
3401  int checksum = 0;
3402 
3403  if (j->dsp.low == 0x20 || j->flags.cidplay)
3404  return;
3405 
3406  j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407  j->cidsize = j->cidcnt = 0;
3408 
3409  ixj_fsk_alloc(j);
3410 
3411  mdmflen = 3;
3412 
3413  if (j->port == PORT_POTS)
3414  SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415 
3416  ixj_write_cid_seize(j);
3417 
3418  ixj_write_cid_byte(j, 0x82);
3419  checksum = 0x82;
3420  ixj_write_cid_byte(j, mdmflen);
3421  checksum = checksum + mdmflen;
3422 
3423  ixj_write_cid_byte(j, 0x0B);
3424  checksum = checksum + 0x0B;
3425  ixj_write_cid_byte(j, 1);
3426  checksum = checksum + 1;
3427 
3428  if(msg) {
3429  ixj_write_cid_byte(j, 0xFF);
3430  checksum = checksum + 0xFF;
3431  }
3432  else {
3433  ixj_write_cid_byte(j, 0x00);
3434  checksum = checksum + 0x00;
3435  }
3436 
3437  checksum %= 256;
3438  checksum ^= 0xFF;
3439  checksum += 1;
3440 
3441  ixj_write_cid_byte(j, (char) checksum);
3442 
3443  pad = j->fskdcnt % 240;
3444  if (pad) {
3445  pad = 240 - pad;
3446  }
3447  ixj_pad_fsk(j, pad);
3448 }
3449 
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452  int cnt, frame_count, dly;
3453  IXJ_WORD dat;
3454 
3455  frame_count = 0;
3456  if(j->flags.cidplay) {
3457  for(cnt = 0; cnt < 480; cnt++) {
3458  if (!(cnt % 16) && !IsTxReady(j)) {
3459  dly = 0;
3460  while (!IsTxReady(j)) {
3461  if (dly++ > 5) {
3462  dly = 0;
3463  break;
3464  }
3465  udelay(10);
3466  }
3467  }
3468  dat.word = j->fskdata[j->cidcnt++];
3469  outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470  outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471  cnt++;
3472  }
3473  if(j->cidcnt >= j->fskdcnt) {
3474  ixj_post_cid(j);
3475  }
3476  /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477  and there is real audio data in the buffer, we need to throw it away because
3478  we just used it's time slot */
3479  if (j->write_buffer_rp > j->write_buffer_wp) {
3480  j->write_buffer_rp += j->cid_play_frame_size * 2;
3481  if (j->write_buffer_rp >= j->write_buffer_end) {
3482  j->write_buffer_rp = j->write_buffer;
3483  }
3484  j->write_buffers_empty++;
3485  wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3486 
3487  wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3488  }
3489  } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490  if (j->write_buffer_wp > j->write_buffer_rp) {
3491  frame_count =
3492  (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493  }
3494  if (j->write_buffer_rp > j->write_buffer_wp) {
3495  frame_count =
3496  (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497  (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498  }
3499  if (frame_count >= 1) {
3500  if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501  BYTES blankword;
3502 
3503  switch (j->play_mode) {
3504  case PLAYBACK_MODE_ULAW:
3505  case PLAYBACK_MODE_ALAW:
3506  blankword.low = blankword.high = 0xFF;
3507  break;
3508  case PLAYBACK_MODE_8LINEAR:
3509  case PLAYBACK_MODE_16LINEAR:
3510  default:
3511  blankword.low = blankword.high = 0x00;
3512  break;
3513  case PLAYBACK_MODE_8LINEAR_WSS:
3514  blankword.low = blankword.high = 0x80;
3515  break;
3516  }
3517  for (cnt = 0; cnt < 16; cnt++) {
3518  if (!(cnt % 16) && !IsTxReady(j)) {
3519  dly = 0;
3520  while (!IsTxReady(j)) {
3521  if (dly++ > 5) {
3522  dly = 0;
3523  break;
3524  }
3525  udelay(10);
3526  }
3527  }
3528  outb_p((blankword.low), j->DSPbase + 0x0C);
3529  outb_p((blankword.high), j->DSPbase + 0x0D);
3530  }
3531  j->flags.play_first_frame = 0;
3532  } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533  for (cnt = 0; cnt < 24; cnt++) {
3534  BYTES blankword;
3535 
3536  if(cnt == 12) {
3537  blankword.low = 0x02;
3538  blankword.high = 0x00;
3539  }
3540  else {
3541  blankword.low = blankword.high = 0x00;
3542  }
3543  if (!(cnt % 16) && !IsTxReady(j)) {
3544  dly = 0;
3545  while (!IsTxReady(j)) {
3546  if (dly++ > 5) {
3547  dly = 0;
3548  break;
3549  }
3550  udelay(10);
3551  }
3552  }
3553  outb_p((blankword.low), j->DSPbase + 0x0C);
3554  outb_p((blankword.high), j->DSPbase + 0x0D);
3555  }
3556  j->flags.play_first_frame = 0;
3557  }
3558  for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559  if (!(cnt % 16) && !IsTxReady(j)) {
3560  dly = 0;
3561  while (!IsTxReady(j)) {
3562  if (dly++ > 5) {
3563  dly = 0;
3564  break;
3565  }
3566  udelay(10);
3567  }
3568  }
3569  /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3570  if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571  if (j->write_buffer_rp[cnt] == 0 &&
3572  j->write_buffer_rp[cnt + 1] == 0 &&
3573  j->write_buffer_rp[cnt + 2] == 0 &&
3574  j->write_buffer_rp[cnt + 3] == 0 &&
3575  j->write_buffer_rp[cnt + 4] == 0 &&
3576  j->write_buffer_rp[cnt + 5] == 0 &&
3577  j->write_buffer_rp[cnt + 6] == 0 &&
3578  j->write_buffer_rp[cnt + 7] == 0 &&
3579  j->write_buffer_rp[cnt + 8] == 0 &&
3580  j->write_buffer_rp[cnt + 9] == 0) {
3581  /* someone is trying to write silence lets make this a type 0 frame. */
3582  outb_p(0x00, j->DSPbase + 0x0C);
3583  outb_p(0x00, j->DSPbase + 0x0D);
3584  } else {
3585  /* so all other frames are type 1. */
3586  outb_p(0x01, j->DSPbase + 0x0C);
3587  outb_p(0x00, j->DSPbase + 0x0D);
3588  }
3589  }
3590  outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591  outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592  *(j->write_buffer_rp + cnt) = 0;
3593  *(j->write_buffer_rp + cnt + 1) = 0;
3594  }
3595  j->write_buffer_rp += j->play_frame_size * 2;
3596  if (j->write_buffer_rp >= j->write_buffer_end) {
3597  j->write_buffer_rp = j->write_buffer;
3598  }
3599  j->write_buffers_empty++;
3600  wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3601 
3602  wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3603 
3604  ++j->frameswritten;
3605  }
3606  } else {
3607  j->drybuffer++;
3608  }
3609  if(j->ixj_signals[SIG_WRITE_READY]) {
3610  ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611  }
3612 }
3613 
3614 static int idle(IXJ *j)
3615 {
3616  if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3617 
3618  return 0;
3619 
3620  if (j->ssr.high || j->ssr.low) {
3621  return 0;
3622  } else {
3623  j->play_mode = -1;
3624  j->flags.playing = 0;
3625  j->rec_mode = -1;
3626  j->flags.recording = 0;
3627  return 1;
3628  }
3629 }
3630 
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633  unsigned short cmd;
3634  int cnt;
3635 
3636  idle(j);
3637  j->cid_play_aec_level = j->aec_level;
3638  aec_stop(j);
3639  for (cnt = 0; cnt < 10; cnt++) {
3640  if (idle(j))
3641  break;
3642  }
3643  if (j->ssr.high || j->ssr.low)
3644  return -1;
3645  if (j->dsp.low != 0x20) {
3646  switch (size) {
3647  case 30:
3648  cmd = 0x07F0;
3649  /* Set Base Frame Size to 240 pg9-10 8021 */
3650  break;
3651  case 20:
3652  cmd = 0x07A0;
3653  /* Set Base Frame Size to 160 pg9-10 8021 */
3654  break;
3655  case 10:
3656  cmd = 0x0750;
3657  /* Set Base Frame Size to 80 pg9-10 8021 */
3658  break;
3659  default:
3660  return -1;
3661  }
3662  } else {
3663  if (size == 30)
3664  return size;
3665  else
3666  return -1;
3667  }
3668  if (ixj_WriteDSPCommand(cmd, j)) {
3669  j->baseframe.high = j->baseframe.low = 0xFF;
3670  return -1;
3671  } else {
3672  j->baseframe.high = j->ssr.high;
3673  j->baseframe.low = j->ssr.low;
3674  /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675  if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676  return -1;
3677  }
3678  }
3679  ixj_aec_start(j, j->cid_play_aec_level);
3680  return size;
3681 }
3682 
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685  int retval = 0;
3686 
3687  j->rec_codec = rate;
3688 
3689  switch (rate) {
3690  case G723_63:
3691  if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692  j->rec_frame_size = 12;
3693  j->rec_mode = 0;
3694  } else {
3695  retval = 1;
3696  }
3697  break;
3698  case G723_53:
3699  if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700  j->rec_frame_size = 10;
3701  j->rec_mode = 0;
3702  } else {
3703  retval = 1;
3704  }
3705  break;
3706  case TS85:
3707  if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708  j->rec_frame_size = 16;
3709  j->rec_mode = 0;
3710  } else {
3711  retval = 1;
3712  }
3713  break;
3714  case TS48:
3715  if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716  j->rec_frame_size = 9;
3717  j->rec_mode = 0;
3718  } else {
3719  retval = 1;
3720  }
3721  break;
3722  case TS41:
3723  if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724  j->rec_frame_size = 8;
3725  j->rec_mode = 0;
3726  } else {
3727  retval = 1;
3728  }
3729  break;
3730  case G728:
3731  if (j->dsp.low != 0x20) {
3732  j->rec_frame_size = 48;
3733  j->rec_mode = 0;
3734  } else {
3735  retval = 1;
3736  }
3737  break;
3738  case G729:
3739  if (j->dsp.low != 0x20) {
3740  if (!j->flags.g729_loaded) {
3741  retval = 1;
3742  break;
3743  }
3744  switch (j->baseframe.low) {
3745  case 0xA0:
3746  j->rec_frame_size = 10;
3747  break;
3748  case 0x50:
3749  j->rec_frame_size = 5;
3750  break;
3751  default:
3752  j->rec_frame_size = 15;
3753  break;
3754  }
3755  j->rec_mode = 0;
3756  } else {
3757  retval = 1;
3758  }
3759  break;
3760  case G729B:
3761  if (j->dsp.low != 0x20) {
3762  if (!j->flags.g729_loaded) {
3763  retval = 1;
3764  break;
3765  }
3766  switch (j->baseframe.low) {
3767  case 0xA0:
3768  j->rec_frame_size = 12;
3769  break;
3770  case 0x50:
3771  j->rec_frame_size = 6;
3772  break;
3773  default:
3774  j->rec_frame_size = 18;
3775  break;
3776  }
3777  j->rec_mode = 0;
3778  } else {
3779  retval = 1;
3780  }
3781  break;
3782  case ULAW:
3783  switch (j->baseframe.low) {
3784  case 0xA0:
3785  j->rec_frame_size = 80;
3786  break;
3787  case 0x50:
3788  j->rec_frame_size = 40;
3789  break;
3790  default:
3791  j->rec_frame_size = 120;
3792  break;
3793  }
3794  j->rec_mode = 4;
3795  break;
3796  case ALAW:
3797  switch (j->baseframe.low) {
3798  case 0xA0:
3799  j->rec_frame_size = 80;
3800  break;
3801  case 0x50:
3802  j->rec_frame_size = 40;
3803  break;
3804  default:
3805  j->rec_frame_size = 120;
3806  break;
3807  }
3808  j->rec_mode = 4;
3809  break;
3810  case LINEAR16:
3811  switch (j->baseframe.low) {
3812  case 0xA0:
3813  j->rec_frame_size = 160;
3814  break;
3815  case 0x50:
3816  j->rec_frame_size = 80;
3817  break;
3818  default:
3819  j->rec_frame_size = 240;
3820  break;
3821  }
3822  j->rec_mode = 5;
3823  break;
3824  case LINEAR8:
3825  switch (j->baseframe.low) {
3826  case 0xA0:
3827  j->rec_frame_size = 80;
3828  break;
3829  case 0x50:
3830  j->rec_frame_size = 40;
3831  break;
3832  default:
3833  j->rec_frame_size = 120;
3834  break;
3835  }
3836  j->rec_mode = 6;
3837  break;
3838  case WSS:
3839  switch (j->baseframe.low) {
3840  case 0xA0:
3841  j->rec_frame_size = 80;
3842  break;
3843  case 0x50:
3844  j->rec_frame_size = 40;
3845  break;
3846  default:
3847  j->rec_frame_size = 120;
3848  break;
3849  }
3850  j->rec_mode = 7;
3851  break;
3852  default:
3853  kfree(j->read_buffer);
3854  j->rec_frame_size = 0;
3855  j->rec_mode = -1;
3856  j->read_buffer = NULL;
3857  j->read_buffer_size = 0;
3858  retval = 1;
3859  break;
3860  }
3861  return retval;
3862 }
3863 
3864 static int ixj_record_start(IXJ *j)
3865 {
3866  unsigned short cmd = 0x0000;
3867 
3868  if (j->read_buffer) {
3869  ixj_record_stop(j);
3870  }
3871  j->flags.recording = 1;
3872  ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873 
3874  if(ixjdebug & 0x0002)
3875  printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876 
3877  if (!j->rec_mode) {
3878  switch (j->rec_codec) {
3879  case G723_63:
3880  cmd = 0x5131;
3881  break;
3882  case G723_53:
3883  cmd = 0x5132;
3884  break;
3885  case TS85:
3886  cmd = 0x5130; /* TrueSpeech 8.5 */
3887 
3888  break;
3889  case TS48:
3890  cmd = 0x5133; /* TrueSpeech 4.8 */
3891 
3892  break;
3893  case TS41:
3894  cmd = 0x5134; /* TrueSpeech 4.1 */
3895 
3896  break;
3897  case G728:
3898  cmd = 0x5135;
3899  break;
3900  case G729:
3901  case G729B:
3902  cmd = 0x5136;
3903  break;
3904  default:
3905  return 1;
3906  }
3907  if (ixj_WriteDSPCommand(cmd, j))
3908  return -1;
3909  }
3910  if (!j->read_buffer) {
3911  if (!j->read_buffer)
3912  j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913  if (!j->read_buffer) {
3914  printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915  return -ENOMEM;
3916  }
3917  }
3918  j->read_buffer_size = j->rec_frame_size * 2;
3919 
3920  if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3921 
3922  return -1;
3923 
3924  switch (j->rec_mode) {
3925  case 0:
3926  cmd = 0x1C03; /* Record C1 */
3927 
3928  break;
3929  case 4:
3930  if (j->ver.low == 0x12) {
3931  cmd = 0x1E03; /* Record C1 */
3932 
3933  } else {
3934  cmd = 0x1E01; /* Record C1 */
3935 
3936  }
3937  break;
3938  case 5:
3939  if (j->ver.low == 0x12) {
3940  cmd = 0x1E83; /* Record C1 */
3941 
3942  } else {
3943  cmd = 0x1E81; /* Record C1 */
3944 
3945  }
3946  break;
3947  case 6:
3948  if (j->ver.low == 0x12) {
3949  cmd = 0x1F03; /* Record C1 */
3950 
3951  } else {
3952  cmd = 0x1F01; /* Record C1 */
3953 
3954  }
3955  break;
3956  case 7:
3957  if (j->ver.low == 0x12) {
3958  cmd = 0x1F83; /* Record C1 */
3959  } else {
3960  cmd = 0x1F81; /* Record C1 */
3961  }
3962  break;
3963  }
3964  if (ixj_WriteDSPCommand(cmd, j))
3965  return -1;
3966 
3967  if (j->flags.playing) {
3968  ixj_aec_start(j, j->aec_level);
3969  }
3970  return 0;
3971 }
3972 
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975  if (ixjdebug & 0x0002)
3976  printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977 
3978  kfree(j->read_buffer);
3979  j->read_buffer = NULL;
3980  j->read_buffer_size = 0;
3981  if (j->rec_mode > -1) {
3982  ixj_WriteDSPCommand(0x5120, j);
3983  j->rec_mode = -1;
3984  }
3985  j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989  if (arg)
3990  ixj_WriteDSPCommand(0x513F, j);
3991  else
3992  ixj_WriteDSPCommand(0x513E, j);
3993 }
3994 
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997  if (depth > 60)
3998  depth = 60;
3999  if (depth < 0)
4000  depth = 0;
4001  ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003 
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006  ixj_WriteDSPCommand(0xCF07, j);
4007  ixj_WriteDSPCommand(volume, j);
4008 }
4009 
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012  ixj_WriteDSPCommand(0xCF05, j);
4013  return j->ssr.high << 8 | j->ssr.low;
4014 }
4015 
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018  if(j->aec_level == AEC_AGC) {
4019  if (ixjdebug & 0x0002)
4020  printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021  ixj_WriteDSPCommand(0xCF96, j);
4022  ixj_WriteDSPCommand(volume, j);
4023  } else {
4024  if (ixjdebug & 0x0002)
4025  printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026  ixj_WriteDSPCommand(0xCF03, j);
4027  ixj_WriteDSPCommand(volume, j);
4028  }
4029 }
4030 
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033  int newvolume, dsprecmax;
4034 
4035  if (ixjdebug & 0x0002)
4036  printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037  if(volume > 100 || volume < 0) {
4038  return -1;
4039  }
4040 
4041  /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042  switch (j->cardtype) {
4043  case QTI_PHONEJACK:
4044  dsprecmax = 0x440;
4045  break;
4046  case QTI_LINEJACK:
4047  dsprecmax = 0x180;
4048  ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4049  ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4050  ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4051  break;
4052  case QTI_PHONEJACK_LITE:
4053  dsprecmax = 0x4C0;
4054  break;
4055  case QTI_PHONEJACK_PCI:
4056  dsprecmax = 0x100;
4057  break;
4058  case QTI_PHONECARD:
4059  dsprecmax = 0x400;
4060  break;
4061  default:
4062  return -1;
4063  }
4064  newvolume = (dsprecmax * volume) / 100;
4065  set_rec_volume(j, newvolume);
4066  return 0;
4067 }
4068 
4069 static int get_rec_volume(IXJ *j)
4070 {
4071  if(j->aec_level == AEC_AGC) {
4072  if (ixjdebug & 0x0002)
4073  printk(KERN_INFO "Getting AGC Threshold\n");
4074  ixj_WriteDSPCommand(0xCF86, j);
4075  if (ixjdebug & 0x0002)
4076  printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077  return j->ssr.high << 8 | j->ssr.low;
4078  } else {
4079  if (ixjdebug & 0x0002)
4080  printk(KERN_INFO "Getting Record Volume\n");
4081  ixj_WriteDSPCommand(0xCF01, j);
4082  return j->ssr.high << 8 | j->ssr.low;
4083  }
4084 }
4085 
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088  int volume, newvolume, dsprecmax;
4089 
4090  switch (j->cardtype) {
4091  case QTI_PHONEJACK:
4092  dsprecmax = 0x440;
4093  break;
4094  case QTI_LINEJACK:
4095  dsprecmax = 0x180;
4096  break;
4097  case QTI_PHONEJACK_LITE:
4098  dsprecmax = 0x4C0;
4099  break;
4100  case QTI_PHONEJACK_PCI:
4101  dsprecmax = 0x100;
4102  break;
4103  case QTI_PHONECARD:
4104  dsprecmax = 0x400;
4105  break;
4106  default:
4107  return -1;
4108  }
4109  volume = get_rec_volume(j);
4110  newvolume = (volume * 100) / dsprecmax;
4111  if(newvolume > 100)
4112  newvolume = 100;
4113  return newvolume;
4114 }
4115 
4116 static int get_rec_level(IXJ *j)
4117 {
4118  int retval;
4119 
4120  ixj_WriteDSPCommand(0xCF88, j);
4121 
4122  retval = j->ssr.high << 8 | j->ssr.low;
4123  retval = (retval * 256) / 240;
4124  return retval;
4125 }
4126 
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129  j->aec_level = level;
4130  if (ixjdebug & 0x0002)
4131  printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132  if (!level) {
4133  aec_stop(j);
4134  } else {
4135  if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136  ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137 
4138  ixj_WriteDSPCommand(0x0300, j);
4139  }
4140  ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141 
4142  ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143 
4144  switch (level) {
4145  case AEC_LOW:
4146  ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147 
4148  ixj_WriteDSPCommand(0xE011, j);
4149  ixj_WriteDSPCommand(0xFFFF, j);
4150 
4151  ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152  ixj_WriteDSPCommand(0x0000, j); /* to off */
4153 
4154  break;
4155 
4156  case AEC_MED:
4157  ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158 
4159  ixj_WriteDSPCommand(0xE011, j);
4160  ixj_WriteDSPCommand(0x0080, j);
4161 
4162  ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163  ixj_WriteDSPCommand(0x0000, j); /* to off */
4164 
4165  break;
4166 
4167  case AEC_HIGH:
4168  ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169 
4170  ixj_WriteDSPCommand(0xE011, j);
4171  ixj_WriteDSPCommand(0x0080, j);
4172 
4173  ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174  ixj_WriteDSPCommand(0x0000, j); /* to off */
4175 
4176  break;
4177 
4178  case AEC_AGC:
4179  /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180  ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181 
4182  ixj_WriteDSPCommand(0xE011, j);
4183  ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184 
4185  ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186 
4187  if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188  ixj_WriteDSPCommand(0x0224, j);
4189  else
4190  ixj_WriteDSPCommand(0x1224, j);
4191 
4192  ixj_WriteDSPCommand(0xE014, j);
4193  ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4194 
4195  ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196 
4197  /* Now we can set the AGC initial parameters and turn it on */
4198  ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minimum gain */
4199  ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200 
4201  ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202  ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203 
4204  ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205  ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206 
4207  ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208  ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209 
4210  ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211  ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212 
4213  ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214  ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215 
4216  ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217  ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218 
4219  ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220  ixj_WriteDSPCommand(0x0001, j); /* to on */
4221 
4222  break;
4223 
4224  case AEC_AUTO:
4225  ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226 
4227  ixj_WriteDSPCommand(0xE011, j);
4228  ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229 
4230  ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231 
4232  if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233  ixj_WriteDSPCommand(0x0224, j);
4234  else
4235  ixj_WriteDSPCommand(0x1224, j);
4236 
4237  ixj_WriteDSPCommand(0xE014, j);
4238  ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4239 
4240  ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241 
4242  break;
4243  }
4244  }
4245 }
4246 
4247 static void aec_stop(IXJ *j)
4248 {
4249  j->aec_level = AEC_OFF;
4250  if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251  ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252 
4253  ixj_WriteDSPCommand(0x0700, j);
4254  }
4255  if (j->play_mode != -1 && j->rec_mode != -1)
4256  {
4257  ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258  }
4259 }
4260 
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263  int retval = 0;
4264 
4265  j->play_codec = rate;
4266 
4267  switch (rate) {
4268  case G723_63:
4269  if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270  j->play_frame_size = 12;
4271  j->play_mode = 0;
4272  } else {
4273  retval = 1;
4274  }
4275  break;
4276  case G723_53:
4277  if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278  j->play_frame_size = 10;
4279  j->play_mode = 0;
4280  } else {
4281  retval = 1;
4282  }
4283  break;
4284  case TS85:
4285  if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286  j->play_frame_size = 16;
4287  j->play_mode = 0;
4288  } else {
4289  retval = 1;
4290  }
4291  break;
4292  case TS48:
4293  if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294  j->play_frame_size = 9;
4295  j->play_mode = 0;
4296  } else {
4297  retval = 1;
4298  }
4299  break;
4300  case TS41:
4301  if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302  j->play_frame_size = 8;
4303  j->play_mode = 0;
4304  } else {
4305  retval = 1;
4306  }
4307  break;
4308  case G728:
4309  if (j->dsp.low != 0x20) {
4310  j->play_frame_size = 48;
4311  j->play_mode = 0;
4312  } else {
4313  retval = 1;
4314  }
4315  break;
4316  case G729:
4317  if (j->dsp.low != 0x20) {
4318  if (!j->flags.g729_loaded) {
4319  retval = 1;
4320  break;
4321  }
4322  switch (j->baseframe.low) {
4323  case 0xA0:
4324  j->play_frame_size = 10;
4325  break;
4326  case 0x50:
4327  j->play_frame_size = 5;
4328  break;
4329  default:
4330  j->play_frame_size = 15;
4331  break;
4332  }
4333  j->play_mode = 0;
4334  } else {
4335  retval = 1;
4336  }
4337  break;
4338  case G729B:
4339  if (j->dsp.low != 0x20) {
4340  if (!j->flags.g729_loaded) {
4341  retval = 1;
4342  break;
4343  }
4344  switch (j->baseframe.low) {
4345  case 0xA0:
4346  j->play_frame_size = 12;
4347  break;
4348  case 0x50:
4349  j->play_frame_size = 6;
4350  break;
4351  default:
4352  j->play_frame_size = 18;
4353  break;
4354  }
4355  j->play_mode = 0;
4356  } else {
4357  retval = 1;
4358  }
4359  break;
4360  case ULAW:
4361  switch (j->baseframe.low) {
4362  case 0xA0:
4363  j->play_frame_size = 80;
4364  break;
4365  case 0x50:
4366  j->play_frame_size = 40;
4367  break;
4368  default:
4369  j->play_frame_size = 120;
4370  break;
4371  }
4372  j->play_mode = 2;
4373  break;
4374  case ALAW:
4375  switch (j->baseframe.low) {
4376  case 0xA0:
4377  j->play_frame_size = 80;
4378  break;
4379  case 0x50:
4380  j->play_frame_size = 40;
4381  break;
4382  default:
4383  j->play_frame_size = 120;
4384  break;
4385  }
4386  j->play_mode = 2;
4387  break;
4388  case LINEAR16:
4389  switch (j->baseframe.low) {
4390  case 0xA0:
4391  j->play_frame_size = 160;
4392  break;
4393  case 0x50:
4394  j->play_frame_size = 80;
4395  break;
4396  default:
4397  j->play_frame_size = 240;
4398  break;
4399  }
4400  j->play_mode = 6;
4401  break;
4402  case LINEAR8:
4403  switch (j->baseframe.low) {
4404  case 0xA0:
4405  j->play_frame_size = 80;
4406  break;
4407  case 0x50:
4408  j->play_frame_size = 40;
4409  break;
4410  default:
4411  j->play_frame_size = 120;
4412  break;
4413  }
4414  j->play_mode = 4;
4415  break;
4416  case WSS:
4417  switch (j->baseframe.low) {
4418  case 0xA0:
4419  j->play_frame_size = 80;
4420  break;
4421  case 0x50:
4422  j->play_frame_size = 40;
4423  break;
4424  default:
4425  j->play_frame_size = 120;
4426  break;
4427  }
4428  j->play_mode = 5;
4429  break;
4430  default:
4431  kfree(j->write_buffer);
4432  j->play_frame_size = 0;
4433  j->play_mode = -1;
4434  j->write_buffer = NULL;
4435  j->write_buffer_size = 0;
4436  retval = 1;
4437  break;
4438  }
4439  return retval;
4440 }
4441 
4442 static int ixj_play_start(IXJ *j)
4443 {
4444  unsigned short cmd = 0x0000;
4445 
4446  if (j->write_buffer) {
4447  ixj_play_stop(j);
4448  }
4449 
4450  if(ixjdebug & 0x0002)
4451  printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452 
4453  j->flags.playing = 1;
4454  ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455 
4456  j->flags.play_first_frame = 1;
4457  j->drybuffer = 0;
4458 
4459  if (!j->play_mode) {
4460  switch (j->play_codec) {
4461  case G723_63:
4462  cmd = 0x5231;
4463  break;
4464  case G723_53:
4465  cmd = 0x5232;
4466  break;
4467  case TS85:
4468  cmd = 0x5230; /* TrueSpeech 8.5 */
4469 
4470  break;
4471  case TS48:
4472  cmd = 0x5233; /* TrueSpeech 4.8 */
4473 
4474  break;
4475  case TS41:
4476  cmd = 0x5234; /* TrueSpeech 4.1 */
4477 
4478  break;
4479  case G728:
4480  cmd = 0x5235;
4481  break;
4482  case G729:
4483  case G729B:
4484  cmd = 0x5236;
4485  break;
4486  default:
4487  return 1;
4488  }
4489  if (ixj_WriteDSPCommand(cmd, j))
4490  return -1;
4491  }
4492  j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493  if (!j->write_buffer) {
4494  printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495  return -ENOMEM;
4496  }
4497 /* j->write_buffers_empty = 2; */
4498  j->write_buffers_empty = 1;
4499  j->write_buffer_size = j->play_frame_size * 2;
4500  j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501  j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502 
4503  if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4504 
4505  return -1;
4506 
4507  switch (j->play_mode) {
4508  case 0:
4509  cmd = 0x2C03;
4510  break;
4511  case 2:
4512  if (j->ver.low == 0x12) {
4513  cmd = 0x2C23;
4514  } else {
4515  cmd = 0x2C21;
4516  }
4517  break;
4518  case 4:
4519  if (j->ver.low == 0x12) {
4520  cmd = 0x2C43;
4521  } else {
4522  cmd = 0x2C41;
4523  }
4524  break;
4525  case 5:
4526  if (j->ver.low == 0x12) {
4527  cmd = 0x2C53;
4528  } else {
4529  cmd = 0x2C51;
4530  }
4531  break;
4532  case 6:
4533  if (j->ver.low == 0x12) {
4534  cmd = 0x2C63;
4535  } else {
4536  cmd = 0x2C61;
4537  }
4538  break;
4539  }
4540  if (ixj_WriteDSPCommand(cmd, j))
4541  return -1;
4542 
4543  if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4544  return -1;
4545 
4546  if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4547  return -1;
4548 
4549  if (j->flags.recording) {
4550  ixj_aec_start(j, j->aec_level);
4551  }
4552 
4553  return 0;
4554 }
4555 
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558  if (ixjdebug & 0x0002)
4559  printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560 
4561  kfree(j->write_buffer);
4562  j->write_buffer = NULL;
4563  j->write_buffer_size = 0;
4564  if (j->play_mode > -1) {
4565  ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4566 
4567  j->play_mode = -1;
4568  }
4569  j->flags.playing = 0;
4570 }
4571 
4572 static inline int get_play_level(IXJ *j)
4573 {
4574  int retval;
4575 
4576  ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577  return j->ssr.high << 8 | j->ssr.low;
4578  retval = j->ssr.high << 8 | j->ssr.low;
4579  retval = (retval * 256) / 240;
4580  return retval;
4581 }
4582 
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585  unsigned int mask = 0;
4586 
4587  IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588 
4589  poll_wait(file_p, &(j->poll_q), wait);
4590  if (j->read_buffer_ready > 0)
4591  mask |= POLLIN | POLLRDNORM; /* readable */
4592  if (j->write_buffers_empty > 0)
4593  mask |= POLLOUT | POLLWRNORM; /* writable */
4594  if (j->ex.bytes)
4595  mask |= POLLPRI;
4596  return mask;
4597 }
4598 
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601  if (!j->tone_state) {
4602  if(ixjdebug & 0x0002) {
4603  printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604  }
4605  if (j->dsp.low == 0x20) {
4606  idle(j);
4607  }
4608  j->tone_start_jif = jiffies;
4609 
4610  j->tone_state = 1;
4611  }
4612 
4613  j->tone_index = tone;
4614  if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615  return -1;
4616 
4617  return 0;
4618 }
4619 
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622  j->tone_on_time = arg;
4623 
4624  if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4625 
4626  return -1;
4627 
4628  if (ixj_WriteDSPCommand(arg, j))
4629  return -1;
4630 
4631  return 0;
4632 }
4633 
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636  int cnt;
4637 
4638  j->pld_scrr.byte = inb_p(j->XILINXbase);
4639  if (!j->pld_scrr.bits.sci) {
4640  for (cnt = 0; cnt < 10; cnt++) {
4641  udelay(32);
4642  j->pld_scrr.byte = inb_p(j->XILINXbase);
4643 
4644  if ((j->pld_scrr.bits.sci))
4645  return 1;
4646  }
4647  if (ixjdebug & 0x0001)
4648  printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649  return 0;
4650  } else
4651  return 1;
4652 }
4653 
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656  int cnt;
4657 
4658  j->pld_scrr.byte = inb_p(j->XILINXbase);
4659  if (j->pld_scrr.bits.sci) {
4660  for (cnt = 0; cnt < 10; cnt++) {
4661  udelay(32);
4662  j->pld_scrr.byte = inb_p(j->XILINXbase);
4663 
4664  if (!(j->pld_scrr.bits.sci))
4665  return 1;
4666  }
4667  if (ixjdebug & 0x0001)
4668  printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669  return 0;
4670  } else
4671  return 1;
4672 }
4673 
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676  switch (control) {
4677  case SCI_End:
4678  j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4679 
4680  j->pld_scrw.bits.c1 = 0; /* to no selection */
4681 
4682  break;
4683  case SCI_Enable_DAA:
4684  j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4685 
4686  j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4687 
4688  break;
4689  case SCI_Enable_Mixer:
4690  j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4691 
4692  j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4693 
4694  break;
4695  case SCI_Enable_EEPROM:
4696  j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4697 
4698  j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4699 
4700  break;
4701  default:
4702  return 0;
4703  break;
4704  }
4705  outb_p(j->pld_scrw.byte, j->XILINXbase);
4706 
4707  switch (control) {
4708  case SCI_End:
4709  return 1;
4710  break;
4711  case SCI_Enable_DAA:
4712  case SCI_Enable_Mixer:
4713  case SCI_Enable_EEPROM:
4714  if (!SCI_WaitHighSCI(j))
4715  return 0;
4716  break;
4717  default:
4718  return 0;
4719  break;
4720  }
4721  return 1;
4722 }
4723 
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726  if (!SCI_Control(j, SCI_End))
4727  return 0;
4728 
4729  if (!SCI_WaitLowSCI(j))
4730  return 0;
4731 
4732  return 1;
4733 }
4734 
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737  int reg = (val & 0x1F00) >> 8;
4738  return j->mix.vol[reg];
4739 }
4740 
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743  BYTES bytes;
4744 
4745  bytes.high = (val & 0x1F00) >> 8;
4746  bytes.low = val & 0x00FF;
4747 
4748  /* save mixer value so we can get back later on */
4749  j->mix.vol[bytes.high] = bytes.low;
4750 
4751  outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4752 
4753  outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4754 
4755  SCI_Control(j, SCI_Enable_Mixer);
4756 
4757  SCI_Control(j, SCI_End);
4758 
4759  return 0;
4760 }
4761 
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764  outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765  outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766  if (!SCI_Control(j, SCI_Enable_DAA))
4767  return 0;
4768  else
4769  return 1;
4770 }
4771 
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774  BYTES bytes;
4775 
4776  switch (j->daa_mode) {
4777  case SOP_PU_SLEEP:
4778  bytes.high = 0x14;
4779  break;
4780  case SOP_PU_RINGING:
4781  bytes.high = 0x54;
4782  break;
4783  case SOP_PU_CONVERSATION:
4784  bytes.high = 0x94;
4785  break;
4786  case SOP_PU_PULSEDIALING:
4787  bytes.high = 0xD4;
4788  break;
4789  }
4790 
4791  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792 
4793  switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794  case 0:
4795  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796  break;
4797  case 1:
4798  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799  break;
4800  case 2:
4801  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802  break;
4803  case 3:
4804  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805  break;
4806  }
4807 
4808  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809 
4810  if (!daa_load(&bytes, j))
4811  return 0;
4812 
4813  if (!SCI_Prepare(j))
4814  return 0;
4815 
4816  return 1;
4817 }
4818 
4819 static char daa_int_read(IXJ *j)
4820 {
4821  BYTES bytes;
4822 
4823  if (!SCI_Prepare(j))
4824  return 0;
4825 
4826  bytes.high = 0x38;
4827  bytes.low = 0x00;
4828  outb_p(bytes.high, j->XILINXbase + 0x03);
4829  outb_p(bytes.low, j->XILINXbase + 0x02);
4830 
4831  if (!SCI_Control(j, SCI_Enable_DAA))
4832  return 0;
4833 
4834  bytes.high = inb_p(j->XILINXbase + 0x03);
4835  bytes.low = inb_p(j->XILINXbase + 0x02);
4836  if (bytes.low != ALISDAA_ID_BYTE) {
4837  if (ixjdebug & 0x0001)
4838  printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839  return 0;
4840  }
4841  if (!SCI_Control(j, SCI_Enable_DAA))
4842  return 0;
4843  if (!SCI_Control(j, SCI_End))
4844  return 0;
4845 
4846  bytes.high = inb_p(j->XILINXbase + 0x03);
4847  bytes.low = inb_p(j->XILINXbase + 0x02);
4848 
4849  j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850 
4851  return 1;
4852 }
4853 
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856  IXJ_WORD wdata;
4857  BYTES bytes;
4858 
4859  if (!SCI_Prepare(j))
4860  return 0;
4861 
4862  switch (j->daa_mode) {
4863  case SOP_PU_SLEEP:
4864  bytes.high = 0x30 + cr;
4865  break;
4866  case SOP_PU_RINGING:
4867  bytes.high = 0x70 + cr;
4868  break;
4869  case SOP_PU_CONVERSATION:
4870  bytes.high = 0xB0 + cr;
4871  break;
4872  case SOP_PU_PULSEDIALING:
4873  default:
4874  bytes.high = 0xF0 + cr;
4875  break;
4876  }
4877 
4878  bytes.low = 0x00;
4879 
4880  outb_p(bytes.high, j->XILINXbase + 0x03);
4881  outb_p(bytes.low, j->XILINXbase + 0x02);
4882 
4883  if (!SCI_Control(j, SCI_Enable_DAA))
4884  return 0;
4885 
4886  bytes.high = inb_p(j->XILINXbase + 0x03);
4887  bytes.low = inb_p(j->XILINXbase + 0x02);
4888  if (bytes.low != ALISDAA_ID_BYTE) {
4889  if (ixjdebug & 0x0001)
4890  printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891  return 0;
4892  }
4893  if (!SCI_Control(j, SCI_Enable_DAA))
4894  return 0;
4895  if (!SCI_Control(j, SCI_End))
4896  return 0;
4897 
4898  wdata.word = inw_p(j->XILINXbase + 0x02);
4899 
4900  switch(cr){
4901  case 5:
4902  j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903  break;
4904  case 4:
4905  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906  break;
4907  case 3:
4908  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909  break;
4910  case 2:
4911  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912  break;
4913  case 1:
4914  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915  break;
4916  case 0:
4917  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918  break;
4919  default:
4920  return 0;
4921  }
4922  return 1;
4923 }
4924 
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927  int i;
4928  BYTES bytes;
4929 
4930  if (ixjdebug & 0x0002)
4931  printk("DAA Clearing CID ram\n");
4932 
4933  if (!SCI_Prepare(j))
4934  return 0;
4935 
4936  bytes.high = 0x58;
4937  bytes.low = 0x00;
4938  outb_p(bytes.high, j->XILINXbase + 0x03);
4939  outb_p(bytes.low, j->XILINXbase + 0x02);
4940 
4941  if (!SCI_Control(j, SCI_Enable_DAA))
4942  return 0;
4943 
4944  if (!SCI_WaitHighSCI(j))
4945  return 0;
4946 
4947  for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948  bytes.high = bytes.low = 0x00;
4949  outb_p(bytes.high, j->XILINXbase + 0x03);
4950 
4951  if (i < ALISDAA_CALLERID_SIZE - 1)
4952  outb_p(bytes.low, j->XILINXbase + 0x02);
4953 
4954  if (!SCI_Control(j, SCI_Enable_DAA))
4955  return 0;
4956 
4957  if (!SCI_WaitHighSCI(j))
4958  return 0;
4959 
4960  }
4961 
4962  if (!SCI_Control(j, SCI_End))
4963  return 0;
4964 
4965  if (ixjdebug & 0x0002)
4966  printk("DAA CID ram cleared\n");
4967 
4968  return 1;
4969 }
4970 
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973  int i;
4974  BYTES bytes;
4975  char CID[ALISDAA_CALLERID_SIZE];
4976  bool mContinue;
4977  char *pIn, *pOut;
4978 
4979  if (!SCI_Prepare(j))
4980  return 0;
4981 
4982  bytes.high = 0x78;
4983  bytes.low = 0x00;
4984  outb_p(bytes.high, j->XILINXbase + 0x03);
4985  outb_p(bytes.low, j->XILINXbase + 0x02);
4986 
4987  if (!SCI_Control(j, SCI_Enable_DAA))
4988  return 0;
4989 
4990  if (!SCI_WaitHighSCI(j))
4991  return 0;
4992 
4993  bytes.high = inb_p(j->XILINXbase + 0x03);
4994  bytes.low = inb_p(j->XILINXbase + 0x02);
4995  if (bytes.low != ALISDAA_ID_BYTE) {
4996  if (ixjdebug & 0x0001)
4997  printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998  return 0;
4999  }
5000  for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001  bytes.high = bytes.low = 0x00;
5002  outb_p(bytes.high, j->XILINXbase + 0x03);
5003  outb_p(bytes.low, j->XILINXbase + 0x02);
5004 
5005  if (!SCI_Control(j, SCI_Enable_DAA))
5006  return 0;
5007 
5008  if (!SCI_WaitHighSCI(j))
5009  return 0;
5010 
5011  CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012  CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013  }
5014 
5015  if (!SCI_Control(j, SCI_End))
5016  return 0;
5017 
5018  pIn = CID;
5019  pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020  mContinue = true;
5021  while (mContinue) {
5022  if ((pIn[1] & 0x03) == 0x01) {
5023  pOut[0] = pIn[0];
5024  }
5025  if ((pIn[2] & 0x0c) == 0x04) {
5026  pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027  }
5028  if ((pIn[3] & 0x30) == 0x10) {
5029  pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030  }
5031  if ((pIn[4] & 0xc0) == 0x40) {
5032  pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033  } else {
5034  mContinue = false;
5035  }
5036  pIn += 5, pOut += 4;
5037  }
5038  memset(&j->cid, 0, sizeof(PHONE_CID));
5039  pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040  pOut += 4;
5041  strncpy(j->cid.month, pOut, 2);
5042  pOut += 2;
5043  strncpy(j->cid.day, pOut, 2);
5044  pOut += 2;
5045  strncpy(j->cid.hour, pOut, 2);
5046  pOut += 2;
5047  strncpy(j->cid.min, pOut, 2);
5048  pOut += 3;
5049  j->cid.numlen = *pOut;
5050  pOut += 1;
5051  strncpy(j->cid.number, pOut, j->cid.numlen);
5052  pOut += j->cid.numlen + 1;
5053  j->cid.namelen = *pOut;
5054  pOut += 1;
5055  strncpy(j->cid.name, pOut, j->cid.namelen);
5056 
5057  ixj_daa_cid_reset(j);
5058  return 1;
5059 }
5060 
5061 static char daa_get_version(IXJ *j)
5062 {
5063  BYTES bytes;
5064 
5065  if (!SCI_Prepare(j))
5066  return 0;
5067 
5068  bytes.high = 0x35;
5069  bytes.low = 0x00;
5070  outb_p(bytes.high, j->XILINXbase + 0x03);
5071  outb_p(bytes.low, j->XILINXbase + 0x02);
5072 
5073  if (!SCI_Control(j, SCI_Enable_DAA))
5074  return 0;
5075 
5076  bytes.high = inb_p(j->XILINXbase + 0x03);
5077  bytes.low = inb_p(j->XILINXbase + 0x02);
5078  if (bytes.low != ALISDAA_ID_BYTE) {
5079  if (ixjdebug & 0x0001)
5080  printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081  return 0;
5082  }
5083  if (!SCI_Control(j, SCI_Enable_DAA))
5084  return 0;
5085 
5086  if (!SCI_Control(j, SCI_End))
5087  return 0;
5088 
5089  bytes.high = inb_p(j->XILINXbase + 0x03);
5090  bytes.low = inb_p(j->XILINXbase + 0x02);
5091  if (ixjdebug & 0x0002)
5092  printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093  j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094  return bytes.high;
5095 }
5096 
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099  /* NOTE:
5100  The DAA *MUST* be in the conversation mode if the
5101  PSTN line is to be seized (PSTN line off-hook).
5102  Taking the PSTN line off-hook while the DAA is in
5103  a mode other than conversation mode will cause a
5104  hardware failure of the ALIS-A part.
5105 
5106  NOTE:
5107  The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108  if the PSTN line is on-hook. Failure to have the PSTN line
5109  in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110  ALIS-A part.
5111  */
5112 
5113  BYTES bytes;
5114 
5115  j->flags.pstn_rmr = 0;
5116 
5117  if (!SCI_Prepare(j))
5118  return 0;
5119 
5120  switch (mode) {
5121  case SOP_PU_RESET:
5122  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5123 
5124  outb_p(j->pld_scrw.byte, j->XILINXbase);
5125  j->pld_slicw.bits.rly2 = 0;
5126  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127  bytes.high = 0x10;
5128  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129  daa_load(&bytes, j);
5130  if (!SCI_Prepare(j))
5131  return 0;
5132 
5133  j->daa_mode = SOP_PU_SLEEP;
5134  break;
5135  case SOP_PU_SLEEP:
5136  if(j->daa_mode == SOP_PU_SLEEP)
5137  {
5138  break;
5139  }
5140  if (ixjdebug & 0x0008)
5141  printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5143  {
5144  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5145 
5146  outb_p(j->pld_scrw.byte, j->XILINXbase);
5147  j->pld_slicw.bits.rly2 = 0;
5148  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149  bytes.high = 0x10;
5150  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151  daa_load(&bytes, j);
5152  if (!SCI_Prepare(j))
5153  return 0;
5154  }
5155  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5156 
5157  outb_p(j->pld_scrw.byte, j->XILINXbase);
5158  j->pld_slicw.bits.rly2 = 0;
5159  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160  bytes.high = 0x10;
5161  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162  daa_load(&bytes, j);
5163  if (!SCI_Prepare(j))
5164  return 0;
5165 
5166  j->daa_mode = SOP_PU_SLEEP;
5167  j->flags.pstn_ringing = 0;
5168  j->ex.bits.pstn_ring = 0;
5169  j->pstn_sleeptil = jiffies + (hertz / 4);
5170  wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5171  wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5172  wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5173  break;
5174  case SOP_PU_RINGING:
5175  if (ixjdebug & 0x0008)
5176  printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5178 
5179  outb_p(j->pld_scrw.byte, j->XILINXbase);
5180  j->pld_slicw.bits.rly2 = 0;
5181  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182  bytes.high = 0x50;
5183  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184  daa_load(&bytes, j);
5185  if (!SCI_Prepare(j))
5186  return 0;
5187  j->daa_mode = SOP_PU_RINGING;
5188  break;
5189  case SOP_PU_CONVERSATION:
5190  if (ixjdebug & 0x0008)
5191  printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192  bytes.high = 0x90;
5193  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194  daa_load(&bytes, j);
5195  if (!SCI_Prepare(j))
5196  return 0;
5197  j->pld_slicw.bits.rly2 = 1;
5198  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199  j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5200 
5201  outb_p(j->pld_scrw.byte, j->XILINXbase);
5202  j->daa_mode = SOP_PU_CONVERSATION;
5203  j->flags.pstn_ringing = 0;
5204  j->ex.bits.pstn_ring = 0;
5205  j->pstn_sleeptil = jiffies;
5206  j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207  break;
5208  case SOP_PU_PULSEDIALING:
5209  if (ixjdebug & 0x0008)
5210  printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5212 
5213  outb_p(j->pld_scrw.byte, j->XILINXbase);
5214  j->pld_slicw.bits.rly2 = 0;
5215  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216  bytes.high = 0xD0;
5217  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218  daa_load(&bytes, j);
5219  if (!SCI_Prepare(j))
5220  return 0;
5221  j->daa_mode = SOP_PU_PULSEDIALING;
5222  break;
5223  default:
5224  break;
5225  }
5226  return 1;
5227 }
5228 
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231  BYTES bytes;
5232 
5233  j->flags.pstncheck = 1;
5234 
5235  daa_set_mode(j, SOP_PU_SLEEP);
5236 
5237  if (!SCI_Prepare(j))
5238  return 0;
5239 
5240  outb_p(j->pld_scrw.byte, j->XILINXbase);
5241 
5242  bytes.high = 0x14;
5243  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244  if (!daa_load(&bytes, j))
5245  return 0;
5246 
5247  bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249  if (!daa_load(&bytes, j))
5250  return 0;
5251 
5252  bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253  bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254  if (!daa_load(&bytes, j))
5255  return 0;
5256 
5257  if (!SCI_Prepare(j))
5258  return 0;
5259 
5260  bytes.high = 0x1F;
5261  bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262  if (!daa_load(&bytes, j))
5263  return 0;
5264 
5265  bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266  bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267  if (!daa_load(&bytes, j))
5268  return 0;
5269 
5270  bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271  bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272  if (!daa_load(&bytes, j))
5273  return 0;
5274 
5275  bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276  bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277  if (!daa_load(&bytes, j))
5278  return 0;
5279 
5280  bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281  bytes.low = 0x00;
5282  if (!daa_load(&bytes, j))
5283  return 0;
5284 
5285  if (!SCI_Prepare(j))
5286  return 0;
5287 
5288  bytes.high = 0x00;
5289  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290  if (!daa_load(&bytes, j))
5291  return 0;
5292 
5293  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295  if (!daa_load(&bytes, j))
5296  return 0;
5297 
5298  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300  if (!daa_load(&bytes, j))
5301  return 0;
5302 
5303  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305  if (!daa_load(&bytes, j))
5306  return 0;
5307 
5308  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309  bytes.low = 0x00;
5310  if (!daa_load(&bytes, j))
5311  return 0;
5312 
5313  if (!SCI_Control(j, SCI_End))
5314  return 0;
5315  if (!SCI_WaitLowSCI(j))
5316  return 0;
5317 
5318  bytes.high = 0x01;
5319  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320  if (!daa_load(&bytes, j))
5321  return 0;
5322 
5323  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325  if (!daa_load(&bytes, j))
5326  return 0;
5327 
5328  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330  if (!daa_load(&bytes, j))
5331  return 0;
5332 
5333  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335  if (!daa_load(&bytes, j))
5336  return 0;
5337 
5338  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339  bytes.low = 0x00;
5340  if (!daa_load(&bytes, j))
5341  return 0;
5342 
5343  if (!SCI_Control(j, SCI_End))
5344  return 0;
5345  if (!SCI_WaitLowSCI(j))
5346  return 0;
5347 
5348  bytes.high = 0x02;
5349  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350  if (!daa_load(&bytes, j))
5351  return 0;
5352 
5353  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355  if (!daa_load(&bytes, j))
5356  return 0;
5357 
5358  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360  if (!daa_load(&bytes, j))
5361  return 0;
5362 
5363  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365  if (!daa_load(&bytes, j))
5366  return 0;
5367 
5368  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369  bytes.low = 0x00;
5370  if (!daa_load(&bytes, j))
5371  return 0;
5372 
5373  if (!SCI_Control(j, SCI_End))
5374  return 0;
5375  if (!SCI_WaitLowSCI(j))
5376  return 0;
5377 
5378  bytes.high = 0x03;
5379  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380  if (!daa_load(&bytes, j))
5381  return 0;
5382 
5383  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385  if (!daa_load(&bytes, j))
5386  return 0;
5387 
5388  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390  if (!daa_load(&bytes, j))
5391  return 0;
5392 
5393  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395  if (!daa_load(&bytes, j))
5396  return 0;
5397 
5398  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399  bytes.low = 0x00;
5400  if (!daa_load(&bytes, j))
5401  return 0;
5402 
5403  if (!SCI_Control(j, SCI_End))
5404  return 0;
5405  if (!SCI_WaitLowSCI(j))
5406  return 0;
5407 
5408  bytes.high = 0x04;
5409  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410  if (!daa_load(&bytes, j))
5411  return 0;
5412 
5413  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415  if (!daa_load(&bytes, j))
5416  return 0;
5417 
5418  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420  if (!daa_load(&bytes, j))
5421  return 0;
5422 
5423  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425  if (!daa_load(&bytes, j))
5426  return 0;
5427 
5428  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429  bytes.low = 0x00;
5430  if (!daa_load(&bytes, j))
5431  return 0;
5432 
5433  if (!SCI_Control(j, SCI_End))
5434  return 0;
5435  if (!SCI_WaitLowSCI(j))
5436  return 0;
5437 
5438  bytes.high = 0x05;
5439  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440  if (!daa_load(&bytes, j))
5441  return 0;
5442 
5443  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445  if (!daa_load(&bytes, j))
5446  return 0;
5447 
5448  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450  if (!daa_load(&bytes, j))
5451  return 0;
5452 
5453  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455  if (!daa_load(&bytes, j))
5456  return 0;
5457 
5458  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459  bytes.low = 0x00;
5460  if (!daa_load(&bytes, j))
5461  return 0;
5462 
5463  if (!SCI_Control(j, SCI_End))
5464  return 0;
5465  if (!SCI_WaitLowSCI(j))
5466  return 0;
5467 
5468  bytes.high = 0x06;
5469  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470  if (!daa_load(&bytes, j))
5471  return 0;
5472 
5473  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475  if (!daa_load(&bytes, j))
5476  return 0;
5477 
5478  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480  if (!daa_load(&bytes, j))
5481  return 0;
5482 
5483  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485  if (!daa_load(&bytes, j))
5486  return 0;
5487 
5488  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489  bytes.low = 0x00;
5490  if (!daa_load(&bytes, j))
5491  return 0;
5492 
5493  if (!SCI_Control(j, SCI_End))
5494  return 0;
5495  if (!SCI_WaitLowSCI(j))
5496  return 0;
5497 
5498  bytes.high = 0x07;
5499  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500  if (!daa_load(&bytes, j))
5501  return 0;
5502 
5503  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505  if (!daa_load(&bytes, j))
5506  return 0;
5507 
5508  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510  if (!daa_load(&bytes, j))
5511  return 0;
5512 
5513  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515  if (!daa_load(&bytes, j))
5516  return 0;
5517 
5518  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519  bytes.low = 0x00;
5520  if (!daa_load(&bytes, j))
5521  return 0;
5522 
5523  if (!SCI_Control(j, SCI_End))
5524  return 0;
5525  if (!SCI_WaitLowSCI(j))
5526  return 0;
5527 
5528  bytes.high = 0x08;
5529  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530  if (!daa_load(&bytes, j))
5531  return 0;
5532 
5533  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535  if (!daa_load(&bytes, j))
5536  return 0;
5537 
5538  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540  if (!daa_load(&bytes, j))
5541  return 0;
5542 
5543  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545  if (!daa_load(&bytes, j))
5546  return 0;
5547 
5548  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549  bytes.low = 0x00;
5550  if (!daa_load(&bytes, j))
5551  return 0;
5552 
5553  if (!SCI_Control(j, SCI_End))
5554  return 0;
5555  if (!SCI_WaitLowSCI(j))
5556  return 0;
5557 
5558  bytes.high = 0x09;
5559  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560  if (!daa_load(&bytes, j))
5561  return 0;
5562 
5563  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565  if (!daa_load(&bytes, j))
5566  return 0;
5567 
5568  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569  bytes.low = 0x00;
5570  if (!daa_load(&bytes, j))
5571  return 0;
5572 
5573  if (!SCI_Control(j, SCI_End))
5574  return 0;
5575  if (!SCI_WaitLowSCI(j))
5576  return 0;
5577 
5578  bytes.high = 0x0A;
5579  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580  if (!daa_load(&bytes, j))
5581  return 0;
5582 
5583  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585  if (!daa_load(&bytes, j))
5586  return 0;
5587 
5588  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589  bytes.low = 0x00;
5590  if (!daa_load(&bytes, j))
5591  return 0;
5592 
5593  if (!SCI_Control(j, SCI_End))
5594  return 0;
5595  if (!SCI_WaitLowSCI(j))
5596  return 0;
5597 
5598  bytes.high = 0x0B;
5599  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600  if (!daa_load(&bytes, j))
5601  return 0;
5602 
5603  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605  if (!daa_load(&bytes, j))
5606  return 0;
5607 
5608  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609  bytes.low = 0x00;
5610  if (!daa_load(&bytes, j))
5611  return 0;
5612 
5613  if (!SCI_Control(j, SCI_End))
5614  return 0;
5615  if (!SCI_WaitLowSCI(j))
5616  return 0;
5617 
5618  bytes.high = 0x0C;
5619  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620  if (!daa_load(&bytes, j))
5621  return 0;
5622 
5623  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625  if (!daa_load(&bytes, j))
5626  return 0;
5627 
5628  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629  bytes.low = 0x00;
5630  if (!daa_load(&bytes, j))
5631  return 0;
5632 
5633  if (!SCI_Control(j, SCI_End))
5634  return 0;
5635  if (!SCI_WaitLowSCI(j))
5636  return 0;
5637 
5638  bytes.high = 0x0D;
5639  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640  if (!daa_load(&bytes, j))
5641  return 0;
5642 
5643  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645  if (!daa_load(&bytes, j))
5646  return 0;
5647 
5648  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649  bytes.low = 0x00;
5650  if (!daa_load(&bytes, j))
5651  return 0;
5652 
5653  if (!SCI_Control(j, SCI_End))
5654  return 0;
5655  if (!SCI_WaitLowSCI(j))
5656  return 0;
5657 
5658  bytes.high = 0x0E;
5659  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660  if (!daa_load(&bytes, j))
5661  return 0;
5662 
5663  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665  if (!daa_load(&bytes, j))
5666  return 0;
5667 
5668  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670  if (!daa_load(&bytes, j))
5671  return 0;
5672 
5673  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675  if (!daa_load(&bytes, j))
5676  return 0;
5677 
5678  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679  bytes.low = 0x00;
5680  if (!daa_load(&bytes, j))
5681  return 0;
5682 
5683  if (!SCI_Control(j, SCI_End))
5684  return 0;
5685  if (!SCI_WaitLowSCI(j))
5686  return 0;
5687 
5688  bytes.high = 0x0F;
5689  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690  if (!daa_load(&bytes, j))
5691  return 0;
5692 
5693  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695  if (!daa_load(&bytes, j))
5696  return 0;
5697 
5698  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700  if (!daa_load(&bytes, j))
5701  return 0;
5702 
5703  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704  bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705  if (!daa_load(&bytes, j))
5706  return 0;
5707 
5708  bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709  bytes.low = 0x00;
5710  if (!daa_load(&bytes, j))
5711  return 0;
5712 
5713  udelay(32);
5714  j->pld_scrr.byte = inb_p(j->XILINXbase);
5715  if (!SCI_Control(j, SCI_End))
5716  return 0;
5717 
5718  outb_p(j->pld_scrw.byte, j->XILINXbase);
5719 
5720  if (ixjdebug & 0x0002)
5721  printk("DAA Coefficients Loaded\n");
5722 
5723  j->flags.pstncheck = 0;
5724  return 1;
5725 }
5726 
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729  j->tone_off_time = arg;
5730  if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5731 
5732  return -1;
5733  if (ixj_WriteDSPCommand(arg, j))
5734  return -1;
5735  return 0;
5736 }
5737 
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740  if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5741 
5742  return -1;
5743  return 0;
5744 }
5745 
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748  if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5749 
5750  return -1;
5751  return 0;
5752 }
5753 
5754 static void ixj_busytone(IXJ *j)
5755 {
5756  j->flags.ringback = 0;
5757  j->flags.dialtone = 0;
5758  j->flags.busytone = 1;
5759  ixj_set_tone_on(0x07D0, j);
5760  ixj_set_tone_off(0x07D0, j);
5761  ixj_play_tone(j, 27);
5762 }
5763 
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766  j->flags.ringback = 0;
5767  j->flags.dialtone = 1;
5768  j->flags.busytone = 0;
5769  if (j->dsp.low == 0x20) {
5770  return;
5771  } else {
5772  ixj_set_tone_on(0xFFFF, j);
5773  ixj_set_tone_off(0x0000, j);
5774  ixj_play_tone(j, 25);
5775  }
5776 }
5777 
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780  if(j->tone_state || j->tone_cadence_state)
5781  {
5782  j->flags.dialtone = 0;
5783  j->flags.busytone = 0;
5784  j->flags.ringback = 0;
5785  ixj_set_tone_on(0x0001, j);
5786  ixj_set_tone_off(0x0000, j);
5787  ixj_play_tone(j, 0);
5788  j->tone_state = j->tone_cadence_state = 0;
5789  if (j->cadence_t) {
5790  kfree(j->cadence_t->ce);
5791  kfree(j->cadence_t);
5792  j->cadence_t = NULL;
5793  }
5794  }
5795  if (j->play_mode == -1 && j->rec_mode == -1)
5796  idle(j);
5797  if (j->play_mode != -1 && j->dsp.low == 0x20)
5798  ixj_play_start(j);
5799  if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800  ixj_record_start(j);
5801 }
5802 
5803 static void ixj_ringback(IXJ *j)
5804 {
5805  j->flags.busytone = 0;
5806  j->flags.dialtone = 0;
5807  j->flags.ringback = 1;
5808  ixj_set_tone_on(0x0FA0, j);
5809  ixj_set_tone_off(0x2EE0, j);
5810  ixj_play_tone(j, 26);
5811 }
5812 
5813 static void ixj_testram(IXJ *j)
5814 {
5815  ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817 
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820  ixj_cadence *lcp;
5821  IXJ_CADENCE_ELEMENT __user *cep;
5822  IXJ_CADENCE_ELEMENT *lcep;
5823  IXJ_TONE ti;
5824  int err;
5825 
5826  lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827  if (lcp == NULL)
5828  return -ENOMEM;
5829 
5830  err = -EFAULT;
5831  if (copy_from_user(&lcp->elements_used,
5832  &cp->elements_used, sizeof(int)))
5833  goto out;
5834  if (copy_from_user(&lcp->termination,
5835  &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836  goto out;
5837  if (get_user(cep, &cp->ce))
5838  goto out;
5839 
5840  err = -EINVAL;
5841  if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842  goto out;
5843 
5844  err = -ENOMEM;
5845  lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846  if (!lcep)
5847  goto out;
5848 
5849  err = -EFAULT;
5850  if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851  goto out1;
5852 
5853  if (j->cadence_t) {
5854  kfree(j->cadence_t->ce);
5855  kfree(j->cadence_t);
5856  }
5857  lcp->ce = (void *) lcep;
5858  j->cadence_t = lcp;
5859  j->tone_cadence_state = 0;
5860  ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861  ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862  if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863  ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864  ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865  ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866  ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867  ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868  ixj_init_tone(j, &ti);
5869  }
5870  ixj_play_tone(j, lcp->ce[0].index);
5871  return 1;
5872 out1:
5873  kfree(lcep);
5874 out:
5875  kfree(lcp);
5876  return err;
5877 }
5878 
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881  IXJ_FILTER_CADENCE *lcp;
5882  lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
5883  if (IS_ERR(lcp)) {
5884  if(ixjdebug & 0x0001) {
5885  printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
5886  }
5887  return PTR_ERR(lcp);
5888  }
5889  if (lcp->filter > 5) {
5890  if(ixjdebug & 0x0001) {
5891  printk(KERN_INFO "Cadence out of range\n");
5892  }
5893  kfree(lcp);
5894  return -1;
5895  }
5896  j->cadence_f[lcp->filter].state = 0;
5897  j->cadence_f[lcp->filter].enable = lcp->enable;
5898  j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5899  j->cadence_f[lcp->filter].on1 = lcp->on1;
5900  j->cadence_f[lcp->filter].on1min = 0;
5901  j->cadence_f[lcp->filter].on1max = 0;
5902  j->cadence_f[lcp->filter].off1 = lcp->off1;
5903  j->cadence_f[lcp->filter].off1min = 0;
5904  j->cadence_f[lcp->filter].off1max = 0;
5905  j->cadence_f[lcp->filter].on2 = lcp->on2;
5906  j->cadence_f[lcp->filter].on2min = 0;
5907  j->cadence_f[lcp->filter].on2max = 0;
5908  j->cadence_f[lcp->filter].off2 = lcp->off2;
5909  j->cadence_f[lcp->filter].off2min = 0;
5910  j->cadence_f[lcp->filter].off2max = 0;
5911  j->cadence_f[lcp->filter].on3 = lcp->on3;
5912  j->cadence_f[lcp->filter].on3min = 0;
5913  j->cadence_f[lcp->filter].on3max = 0;
5914  j->cadence_f[lcp->filter].off3 = lcp->off3;
5915  j->cadence_f[lcp->filter].off3min = 0;
5916  j->cadence_f[lcp->filter].off3max = 0;
5917  if(ixjdebug & 0x0002) {
5918  printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5919  }
5920  kfree(lcp);
5921  return 0;
5922 }
5923 
5924 static void add_caps(IXJ *j)
5925 {
5926  j->caps = 0;
5927  j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5928  strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5929  j->caplist[j->caps].captype = vendor;
5930  j->caplist[j->caps].handle = j->caps;
5931  j->caps++;
5932  j->caplist[j->caps].captype = device;
5933  switch (j->cardtype) {
5934  case QTI_PHONEJACK:
5935  strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5936  break;
5937  case QTI_LINEJACK:
5938  strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5939  break;
5940  case QTI_PHONEJACK_LITE:
5941  strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5942  break;
5943  case QTI_PHONEJACK_PCI:
5944  strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5945  break;
5946  case QTI_PHONECARD:
5947  strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5948  break;
5949  }
5950  j->caplist[j->caps].cap = j->cardtype;
5951  j->caplist[j->caps].handle = j->caps;
5952  j->caps++;
5953  strcpy(j->caplist[j->caps].desc, "POTS");
5954  j->caplist[j->caps].captype = port;
5955  j->caplist[j->caps].cap = pots;
5956  j->caplist[j->caps].handle = j->caps;
5957  j->caps++;
5958 
5959  /* add devices that can do speaker/mic */
5960  switch (j->cardtype) {
5961  case QTI_PHONEJACK:
5962  case QTI_LINEJACK:
5963  case QTI_PHONEJACK_PCI:
5964  case QTI_PHONECARD:
5965  strcpy(j->caplist[j->caps].desc, "SPEAKER");
5966  j->caplist[j->caps].captype = port;
5967  j->caplist[j->caps].cap = speaker;
5968  j->caplist[j->caps].handle = j->caps;
5969  j->caps++;
5970  default:
5971  break;
5972  }
5973 
5974  /* add devices that can do handset */
5975  switch (j->cardtype) {
5976  case QTI_PHONEJACK:
5977  strcpy(j->caplist[j->caps].desc, "HANDSET");
5978  j->caplist[j->caps].captype = port;
5979  j->caplist[j->caps].cap = handset;
5980  j->caplist[j->caps].handle = j->caps;
5981  j->caps++;
5982  break;
5983  default:
5984  break;
5985  }
5986 
5987  /* add devices that can do PSTN */
5988  switch (j->cardtype) {
5989  case QTI_LINEJACK:
5990  strcpy(j->caplist[j->caps].desc, "PSTN");
5991  j->caplist[j->caps].captype = port;
5992  j->caplist[j->caps].cap = pstn;
5993  j->caplist[j->caps].handle = j->caps;
5994  j->caps++;
5995  break;
5996  default:
5997  break;
5998  }
5999 
6000  /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6001  strcpy(j->caplist[j->caps].desc, "ULAW");
6002  j->caplist[j->caps].captype = codec;
6003  j->caplist[j->caps].cap = ULAW;
6004  j->caplist[j->caps].handle = j->caps;
6005  j->caps++;
6006 
6007  strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6008  j->caplist[j->caps].captype = codec;
6009  j->caplist[j->caps].cap = LINEAR16;
6010  j->caplist[j->caps].handle = j->caps;
6011  j->caps++;
6012 
6013  strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6014  j->caplist[j->caps].captype = codec;
6015  j->caplist[j->caps].cap = LINEAR8;
6016  j->caplist[j->caps].handle = j->caps;
6017  j->caps++;
6018 
6019  strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6020  j->caplist[j->caps].captype = codec;
6021  j->caplist[j->caps].cap = WSS;
6022  j->caplist[j->caps].handle = j->caps;
6023  j->caps++;
6024 
6025  /* software ALAW codec, made from ULAW */
6026  strcpy(j->caplist[j->caps].desc, "ALAW");
6027  j->caplist[j->caps].captype = codec;
6028  j->caplist[j->caps].cap = ALAW;
6029  j->caplist[j->caps].handle = j->caps;
6030  j->caps++;
6031 
6032  /* version 12 of the 8020 does the following codecs in a broken way */
6033  if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6034  strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6035  j->caplist[j->caps].captype = codec;
6036  j->caplist[j->caps].cap = G723_63;
6037  j->caplist[j->caps].handle = j->caps;
6038  j->caps++;
6039 
6040  strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6041  j->caplist[j->caps].captype = codec;
6042  j->caplist[j->caps].cap = G723_53;
6043  j->caplist[j->caps].handle = j->caps;
6044  j->caps++;
6045 
6046  strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6047  j->caplist[j->caps].captype = codec;
6048  j->caplist[j->caps].cap = TS48;
6049  j->caplist[j->caps].handle = j->caps;
6050  j->caps++;
6051 
6052  strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6053  j->caplist[j->caps].captype = codec;
6054  j->caplist[j->caps].cap = TS41;
6055  j->caplist[j->caps].handle = j->caps;
6056  j->caps++;
6057  }
6058 
6059  /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6060  if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6061  strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6062  j->caplist[j->caps].captype = codec;
6063  j->caplist[j->caps].cap = TS85;
6064  j->caplist[j->caps].handle = j->caps;
6065  j->caps++;
6066  }
6067 
6068  /* 8021 chips can do G728 */
6069  if (j->dsp.low == 0x21) {
6070  strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6071  j->caplist[j->caps].captype = codec;
6072  j->caplist[j->caps].cap = G728;
6073  j->caplist[j->caps].handle = j->caps;
6074  j->caps++;
6075  }
6076 
6077  /* 8021/8022 chips can do G729 if loaded */
6078  if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6079  strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6080  j->caplist[j->caps].captype = codec;
6081  j->caplist[j->caps].cap = G729;
6082  j->caplist[j->caps].handle = j->caps;
6083  j->caps++;
6084  }
6085  if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6086  strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6087  j->caplist[j->caps].captype = codec;
6088  j->caplist[j->caps].cap = G729B;
6089  j->caplist[j->caps].handle = j->caps;
6090  j->caps++;
6091  }
6092 }
6093 
6094 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6095 {
6096  int cnt;
6097  int retval = 0;
6098  for (cnt = 0; cnt < j->caps; cnt++) {
6099  if (pcreq->captype == j->caplist[cnt].captype
6100  && pcreq->cap == j->caplist[cnt].cap) {
6101  retval = 1;
6102  break;
6103  }
6104  }
6105  return retval;
6106 }
6107 
6108 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6109 {
6110  IXJ_TONE ti;
6111  IXJ_FILTER jf;
6112  IXJ_FILTER_RAW jfr;
6113  void __user *argp = (void __user *)arg;
6114  struct inode *inode = file_p->f_path.dentry->d_inode;
6115  unsigned int minor = iminor(inode);
6116  unsigned int raise, mant;
6117  int board = NUM(inode);
6118 
6119  IXJ *j = get_ixj(NUM(inode));
6120 
6121  int retval = 0;
6122 
6123  /*
6124  * Set up locks to ensure that only one process is talking to the DSP at a time.
6125  * This is necessary to keep the DSP from locking up.
6126  */
6127  while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6128  schedule_timeout_interruptible(1);
6129  if (ixjdebug & 0x0040)
6130  printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6131  if (minor >= IXJMAX) {
6132  clear_bit(board, &j->busyflags);
6133  return -ENODEV;
6134  }
6135  /*
6136  * Check ioctls only root can use.
6137  */
6138  if (!capable(CAP_SYS_ADMIN)) {
6139  switch (cmd) {
6140  case IXJCTL_TESTRAM:
6141  case IXJCTL_HZ:
6142  retval = -EPERM;
6143  }
6144  }
6145  switch (cmd) {
6146  case IXJCTL_TESTRAM:
6147  ixj_testram(j);
6148  retval = (j->ssr.high << 8) + j->ssr.low;
6149  break;
6150  case IXJCTL_CARDTYPE:
6151  retval = j->cardtype;
6152  break;
6153  case IXJCTL_SERIAL:
6154  retval = j->serial;
6155  break;
6156  case IXJCTL_VERSION:
6157  {
6158  char arg_str[100];
6159  snprintf(arg_str, sizeof(arg_str),
6160  "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6161  IXJ_VER_MINOR, IXJ_BLD_VER);
6162  if (copy_to_user(argp, arg_str, strlen(arg_str)))
6163  retval = -EFAULT;
6164  }
6165  break;
6166  case PHONE_RING_CADENCE:
6167  j->ring_cadence = arg;
6168  break;
6169  case IXJCTL_CIDCW:
6170  if(arg) {
6171  if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6172  retval = -EFAULT;
6173  break;
6174  }
6175  } else {
6176  memset(&j->cid_send, 0, sizeof(PHONE_CID));
6177  }
6178  ixj_write_cidcw(j);
6179  break;
6180  /* Binary compatbility */
6181  case OLD_PHONE_RING_START:
6182  arg = 0;
6183  /* Fall through */
6184  case PHONE_RING_START:
6185  if(arg) {
6186  if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6187  retval = -EFAULT;
6188  break;
6189  }
6190  ixj_write_cid(j);
6191  } else {
6192  memset(&j->cid_send, 0, sizeof(PHONE_CID));
6193  }
6194  ixj_ring_start(j);
6195  break;
6196  case PHONE_RING_STOP:
6197  j->flags.cringing = 0;
6198  if(j->cadence_f[5].enable) {
6199  j->cadence_f[5].state = 0;
6200  }
6201  ixj_ring_off(j);
6202  break;
6203  case PHONE_RING:
6204  retval = ixj_ring(j);
6205  break;
6206  case PHONE_EXCEPTION:
6207  retval = j->ex.bytes;
6208  if(j->ex.bits.flash) {
6209  j->flash_end = 0;
6210  j->ex.bits.flash = 0;
6211  }
6212  j->ex.bits.pstn_ring = 0;
6213  j->ex.bits.caller_id = 0;
6214  j->ex.bits.pstn_wink = 0;
6215  j->ex.bits.f0 = 0;
6216  j->ex.bits.f1 = 0;
6217  j->ex.bits.f2 = 0;
6218  j->ex.bits.f3 = 0;
6219  j->ex.bits.fc0 = 0;
6220  j->ex.bits.fc1 = 0;
6221  j->ex.bits.fc2 = 0;
6222  j->ex.bits.fc3 = 0;
6223  j->ex.bits.reserved = 0;
6224  break;
6225  case PHONE_HOOKSTATE:
6226  j->ex.bits.hookstate = 0;
6227  retval = j->hookstate; //j->r_hook;
6228  break;
6229  case IXJCTL_SET_LED:
6230  LED_SetState(arg, j);
6231  break;
6232  case PHONE_FRAME:
6233  retval = set_base_frame(j, arg);
6234  break;
6235  case PHONE_REC_CODEC:
6236  retval = set_rec_codec(j, arg);
6237  break;
6238  case PHONE_VAD:
6239  ixj_vad(j, arg);
6240  break;
6241  case PHONE_REC_START:
6242  ixj_record_start(j);
6243  break;
6244  case PHONE_REC_STOP:
6245  ixj_record_stop(j);
6246  break;
6247  case PHONE_REC_DEPTH:
6248  set_rec_depth(j, arg);
6249  break;
6250  case PHONE_REC_VOLUME:
6251  if(arg == -1) {
6252  retval = get_rec_volume(j);
6253  }
6254  else {
6255  set_rec_volume(j, arg);
6256  retval = arg;
6257  }
6258  break;
6259  case PHONE_REC_VOLUME_LINEAR:
6260  if(arg == -1) {
6261  retval = get_rec_volume_linear(j);
6262  }
6263  else {
6264  set_rec_volume_linear(j, arg);
6265  retval = arg;
6266  }
6267  break;
6268  case IXJCTL_DTMF_PRESCALE:
6269  if(arg == -1) {
6270  retval = get_dtmf_prescale(j);
6271  }
6272  else {
6273  set_dtmf_prescale(j, arg);
6274  retval = arg;
6275  }
6276  break;
6277  case PHONE_REC_LEVEL:
6278  retval = get_rec_level(j);
6279  break;
6280  case IXJCTL_SC_RXG:
6281  retval = ixj_siadc(j, arg);
6282  break;
6283  case IXJCTL_SC_TXG:
6284  retval = ixj_sidac(j, arg);
6285  break;
6286  case IXJCTL_AEC_START:
6287  ixj_aec_start(j, arg);
6288  break;
6289  case IXJCTL_AEC_STOP:
6290  aec_stop(j);
6291  break;
6292  case IXJCTL_AEC_GET_LEVEL:
6293  retval = j->aec_level;
6294  break;
6295  case PHONE_PLAY_CODEC:
6296  retval = set_play_codec(j, arg);
6297  break;
6298  case PHONE_PLAY_START:
6299  retval = ixj_play_start(j);
6300  break;
6301  case PHONE_PLAY_STOP:
6302  ixj_play_stop(j);
6303  break;
6304  case PHONE_PLAY_DEPTH:
6305  set_play_depth(j, arg);
6306  break;
6307  case PHONE_PLAY_VOLUME:
6308  if(arg == -1) {
6309  retval = get_play_volume(j);
6310  }
6311  else {
6312  set_play_volume(j, arg);
6313  retval = arg;
6314  }
6315  break;
6316  case PHONE_PLAY_VOLUME_LINEAR:
6317  if(arg == -1) {
6318  retval = get_play_volume_linear(j);
6319  }
6320  else {
6321  set_play_volume_linear(j, arg);
6322  retval = arg;
6323  }
6324  break;
6325  case PHONE_PLAY_LEVEL:
6326  retval = get_play_level(j);
6327  break;
6328  case IXJCTL_DSP_TYPE:
6329  retval = (j->dsp.high << 8) + j->dsp.low;
6330  break;
6331  case IXJCTL_DSP_VERSION:
6332  retval = (j->ver.high << 8) + j->ver.low;
6333  break;
6334  case IXJCTL_HZ:
6335  hertz = arg;
6336  break;
6337  case IXJCTL_RATE:
6338  if (arg > hertz)
6339  retval = -1;
6340  else
6341  samplerate = arg;
6342  break;
6343  case IXJCTL_DRYBUFFER_READ:
6344  put_user(j->drybuffer, (unsigned long __user *) argp);
6345  break;
6346  case IXJCTL_DRYBUFFER_CLEAR:
6347  j->drybuffer = 0;
6348  break;
6349  case IXJCTL_FRAMES_READ:
6350  put_user(j->framesread, (unsigned long __user *) argp);
6351  break;
6352  case IXJCTL_FRAMES_WRITTEN:
6353  put_user(j->frameswritten, (unsigned long __user *) argp);
6354  break;
6355  case IXJCTL_READ_WAIT:
6356  put_user(j->read_wait, (unsigned long __user *) argp);
6357  break;
6358  case IXJCTL_WRITE_WAIT:
6359  put_user(j->write_wait, (unsigned long __user *) argp);
6360  break;
6361  case PHONE_MAXRINGS:
6362  j->maxrings = arg;
6363  break;
6364  case PHONE_SET_TONE_ON_TIME:
6365  ixj_set_tone_on(arg, j);
6366  break;
6367  case PHONE_SET_TONE_OFF_TIME:
6368  ixj_set_tone_off(arg, j);
6369  break;
6370  case PHONE_GET_TONE_ON_TIME:
6371  if (ixj_get_tone_on(j)) {
6372  retval = -1;
6373  } else {
6374  retval = (j->ssr.high << 8) + j->ssr.low;
6375  }
6376  break;
6377  case PHONE_GET_TONE_OFF_TIME:
6378  if (ixj_get_tone_off(j)) {
6379  retval = -1;
6380  } else {
6381  retval = (j->ssr.high << 8) + j->ssr.low;
6382  }
6383  break;
6384  case PHONE_PLAY_TONE:
6385  if (!j->tone_state)
6386  retval = ixj_play_tone(j, arg);
6387  else
6388  retval = -1;
6389  break;
6390  case PHONE_GET_TONE_STATE:
6391  retval = j->tone_state;
6392  break;
6393  case PHONE_DTMF_READY:
6394  retval = j->ex.bits.dtmf_ready;
6395  break;
6396  case PHONE_GET_DTMF:
6397  if (ixj_hookstate(j)) {
6398  if (j->dtmf_rp != j->dtmf_wp) {
6399  retval = j->dtmfbuffer[j->dtmf_rp];
6400  j->dtmf_rp++;
6401  if (j->dtmf_rp == 79)
6402  j->dtmf_rp = 0;
6403  if (j->dtmf_rp == j->dtmf_wp) {
6404  j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6405  }
6406  }
6407  }
6408  break;
6409  case PHONE_GET_DTMF_ASCII:
6410  if (ixj_hookstate(j)) {
6411  if (j->dtmf_rp != j->dtmf_wp) {
6412  switch (j->dtmfbuffer[j->dtmf_rp]) {
6413  case 10:
6414  retval = 42; /* '*'; */
6415 
6416  break;
6417  case 11:
6418  retval = 48; /*'0'; */
6419 
6420  break;
6421  case 12:
6422  retval = 35; /*'#'; */
6423 
6424  break;
6425  case 28:
6426  retval = 65; /*'A'; */
6427 
6428  break;
6429  case 29:
6430  retval = 66; /*'B'; */
6431 
6432  break;
6433  case 30:
6434  retval = 67; /*'C'; */
6435 
6436  break;
6437  case 31:
6438  retval = 68; /*'D'; */
6439 
6440  break;
6441  default:
6442  retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6443  break;
6444  }
6445  j->dtmf_rp++;
6446  if (j->dtmf_rp == 79)
6447  j->dtmf_rp = 0;
6448  if(j->dtmf_rp == j->dtmf_wp)
6449  {
6450  j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6451  }
6452  }
6453  }
6454  break;
6455  case PHONE_DTMF_OOB:
6456  j->flags.dtmf_oob = arg;
6457  break;
6458  case PHONE_DIALTONE:
6459  ixj_dialtone(j);
6460  break;
6461  case PHONE_BUSY:
6462  ixj_busytone(j);
6463  break;
6464  case PHONE_RINGBACK:
6465  ixj_ringback(j);
6466  break;
6467  case PHONE_WINK:
6468  if(j->cardtype == QTI_PHONEJACK)
6469  retval = -1;
6470  else
6471  retval = ixj_wink(j);
6472  break;
6473  case PHONE_CPT_STOP:
6474  ixj_cpt_stop(j);
6475  break;
6476  case PHONE_QUERY_CODEC:
6477  {
6478  struct phone_codec_data pd;
6479  int val;
6480  int proto_size[] = {
6481  -1,
6482  12, 10, 16, 9, 8, 48, 5,
6483  40, 40, 80, 40, 40, 6
6484  };
6485  if(copy_from_user(&pd, argp, sizeof(pd))) {
6486  retval = -EFAULT;
6487  break;
6488  }
6489  if(pd.type<1 || pd.type>13) {
6490  retval = -EPROTONOSUPPORT;
6491  break;
6492  }
6493  if(pd.type<G729)
6494  val=proto_size[pd.type];
6495  else switch(j->baseframe.low)
6496  {
6497  case 0xA0:val=2*proto_size[pd.type];break;
6498  case 0x50:val=proto_size[pd.type];break;
6499  default:val=proto_size[pd.type]*3;break;
6500  }
6501  pd.buf_min=pd.buf_max=pd.buf_opt=val;
6502  if(copy_to_user(argp, &pd, sizeof(pd)))
6503  retval = -EFAULT;
6504  break;
6505  }
6506  case IXJCTL_DSP_IDLE:
6507  idle(j);
6508  break;
6509  case IXJCTL_MIXER:
6510  if ((arg & 0xff) == 0xff)
6511  retval = ixj_get_mixer(arg, j);
6512  else
6513  ixj_mixer(arg, j);
6514  break;
6515  case IXJCTL_DAA_COEFF_SET:
6516  switch (arg) {
6517  case DAA_US:
6518  DAA_Coeff_US(j);
6519  retval = ixj_daa_write(j);
6520  break;
6521  case DAA_UK:
6522  DAA_Coeff_UK(j);
6523  retval = ixj_daa_write(j);
6524  break;
6525  case DAA_FRANCE:
6526  DAA_Coeff_France(j);
6527  retval = ixj_daa_write(j);
6528  break;
6529  case DAA_GERMANY:
6530  DAA_Coeff_Germany(j);
6531  retval = ixj_daa_write(j);
6532  break;
6533  case DAA_AUSTRALIA:
6534  DAA_Coeff_Australia(j);
6535  retval = ixj_daa_write(j);
6536  break;
6537  case DAA_JAPAN:
6538  DAA_Coeff_Japan(j);
6539  retval = ixj_daa_write(j);
6540  break;
6541  default:
6542  retval = 1;
6543  break;
6544  }
6545  break;
6546  case IXJCTL_DAA_AGAIN:
6547  ixj_daa_cr4(j, arg | 0x02);
6548  break;
6549  case IXJCTL_PSTN_LINETEST:
6550  retval = ixj_linetest(j);
6551  break;
6552  case IXJCTL_VMWI:
6553  ixj_write_vmwi(j, arg);
6554  break;
6555  case IXJCTL_CID:
6556  if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6557  retval = -EFAULT;
6558  j->ex.bits.caller_id = 0;
6559  break;
6560  case IXJCTL_WINK_DURATION:
6561  j->winktime = arg;
6562  break;
6563  case IXJCTL_PORT:
6564  if (arg)
6565  retval = ixj_set_port(j, arg);
6566  else
6567  retval = j->port;
6568  break;
6569  case IXJCTL_POTS_PSTN:
6570  retval = ixj_set_pots(j, arg);
6571  break;
6572  case PHONE_CAPABILITIES:
6573  add_caps(j);
6574  retval = j->caps;
6575  break;
6576  case PHONE_CAPABILITIES_LIST:
6577  add_caps(j);
6578  if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6579  retval = -EFAULT;
6580  break;
6581  case PHONE_CAPABILITIES_CHECK:
6582  {
6583  struct phone_capability cap;
6584  if (copy_from_user(&cap, argp, sizeof(cap)))
6585  retval = -EFAULT;
6586  else {
6587  add_caps(j);
6588  retval = capabilities_check(j, &cap);
6589  }
6590  }
6591  break;
6592  case PHONE_PSTN_SET_STATE:
6593  daa_set_mode(j, arg);
6594  break;
6595  case PHONE_PSTN_GET_STATE:
6596  retval = j->daa_mode;
6597  j->ex.bits.pstn_ring = 0;
6598  break;
6599  case IXJCTL_SET_FILTER:
6600  if (copy_from_user(&jf, argp, sizeof(jf)))
6601  retval = -EFAULT;
6602  else
6603  retval = ixj_init_filter(j, &jf);
6604  break;
6605  case IXJCTL_SET_FILTER_RAW:
6606  if (copy_from_user(&jfr, argp, sizeof(jfr)))
6607  retval = -EFAULT;
6608  else
6609  retval = ixj_init_filter_raw(j, &jfr);
6610  break;
6611  case IXJCTL_GET_FILTER_HIST:
6612  if(arg<0||arg>3)
6613  retval = -EINVAL;
6614  else
6615  retval = j->filter_hist[arg];
6616  break;
6617  case IXJCTL_INIT_TONE:
6618  if (copy_from_user(&ti, argp, sizeof(ti)))
6619  retval = -EFAULT;
6620  else
6621  retval = ixj_init_tone(j, &ti);
6622  break;
6623  case IXJCTL_TONE_CADENCE:
6624  retval = ixj_build_cadence(j, argp);
6625  break;
6626  case IXJCTL_FILTER_CADENCE:
6627  retval = ixj_build_filter_cadence(j, argp);
6628  break;
6629  case IXJCTL_SIGCTL:
6630  if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6631  retval = -EFAULT;
6632  break;
6633  }
6634  j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6635  if(j->sigdef.event < 33) {
6636  raise = 1;
6637  for(mant = 0; mant < j->sigdef.event; mant++){
6638  raise *= 2;
6639  }
6640  if(j->sigdef.signal)
6641  j->ex_sig.bytes |= raise;
6642  else
6643  j->ex_sig.bytes &= (raise^0xffff);
6644  }
6645  break;
6646  case IXJCTL_INTERCOM_STOP:
6647  if(arg < 0 || arg >= IXJMAX)
6648  return -EINVAL;
6649  j->intercom = -1;
6650  ixj_record_stop(j);
6651  ixj_play_stop(j);
6652  idle(j);
6653  get_ixj(arg)->intercom = -1;
6654  ixj_record_stop(get_ixj(arg));
6655  ixj_play_stop(get_ixj(arg));
6656  idle(get_ixj(arg));
6657  break;
6658  case IXJCTL_INTERCOM_START:
6659  if(arg < 0 || arg >= IXJMAX)
6660  return -EINVAL;
6661  j->intercom = arg;
6662  ixj_record_start(j);
6663  ixj_play_start(j);
6664  get_ixj(arg)->intercom = board;
6665  ixj_play_start(get_ixj(arg));
6666  ixj_record_start(get_ixj(arg));
6667  break;
6668  }
6669  if (ixjdebug & 0x0040)
6670  printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6671  clear_bit(board, &j->busyflags);
6672  return retval;
6673 }
6674 
6675 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6676 {
6677  long ret;
6678  mutex_lock(&ixj_mutex);
6679  ret = do_ixj_ioctl(file_p, cmd, arg);
6680  mutex_unlock(&ixj_mutex);
6681  return ret;
6682 }
6683 
6684 static int ixj_fasync(int fd, struct file *file_p, int mode)
6685 {
6686  IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6687 
6688  return fasync_helper(fd, file_p, mode, &j->async_queue);
6689 }
6690 
6691 static const struct file_operations ixj_fops =
6692 {
6693  .owner = THIS_MODULE,
6694  .read = ixj_enhanced_read,
6695  .write = ixj_enhanced_write,
6696  .poll = ixj_poll,
6697  .unlocked_ioctl = ixj_ioctl,
6698  .release = ixj_release,
6699  .fasync = ixj_fasync,
6700  .llseek = default_llseek,
6701 };
6702 
6703 static int ixj_linetest(IXJ *j)
6704 {
6705  j->flags.pstncheck = 1; /* Testing */
6706  j->flags.pstn_present = 0; /* Assume the line is not there */
6707 
6708  daa_int_read(j); /*Clear DAA Interrupt flags */
6709  /* */
6710  /* Hold all relays in the normally de-energized position. */
6711  /* */
6712 
6713  j->pld_slicw.bits.rly1 = 0;
6714  j->pld_slicw.bits.rly2 = 0;
6715  j->pld_slicw.bits.rly3 = 0;
6716  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6717  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6718 
6719  outb_p(j->pld_scrw.byte, j->XILINXbase);
6720  j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6721  if (j->pld_slicr.bits.potspstn) {
6722  j->flags.pots_pstn = 1;
6723  j->flags.pots_correct = 0;
6724  LED_SetState(0x4, j);
6725  } else {
6726  j->flags.pots_pstn = 0;
6727  j->pld_slicw.bits.rly1 = 0;
6728  j->pld_slicw.bits.rly2 = 0;
6729  j->pld_slicw.bits.rly3 = 1;
6730  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6732 
6733  outb_p(j->pld_scrw.byte, j->XILINXbase);
6734  daa_set_mode(j, SOP_PU_CONVERSATION);
6735  msleep(1000);
6736  daa_int_read(j);
6737  daa_set_mode(j, SOP_PU_RESET);
6738  if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6739  j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6740  LED_SetState(0x4, j);
6741  j->pld_slicw.bits.rly3 = 0;
6742  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6743  } else {
6744  j->flags.pots_correct = 1;
6745  LED_SetState(0x8, j);
6746  j->pld_slicw.bits.rly1 = 1;
6747  j->pld_slicw.bits.rly2 = 0;
6748  j->pld_slicw.bits.rly3 = 0;
6749  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6750  }
6751  }
6752  j->pld_slicw.bits.rly3 = 0;
6753  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6754  daa_set_mode(j, SOP_PU_CONVERSATION);
6755  msleep(1000);
6756  daa_int_read(j);
6757  daa_set_mode(j, SOP_PU_RESET);
6758  if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6759  j->pstn_sleeptil = jiffies + (hertz / 4);
6760  j->flags.pstn_present = 1;
6761  } else {
6762  j->flags.pstn_present = 0;
6763  }
6764  if (j->flags.pstn_present) {
6765  if (j->flags.pots_correct) {
6766  LED_SetState(0xA, j);
6767  } else {
6768  LED_SetState(0x6, j);
6769  }
6770  } else {
6771  if (j->flags.pots_correct) {
6772  LED_SetState(0x9, j);
6773  } else {
6774  LED_SetState(0x5, j);
6775  }
6776  }
6777  j->flags.pstncheck = 0; /* Testing */
6778  return j->flags.pstn_present;
6779 }
6780 
6781 static int ixj_selfprobe(IXJ *j)
6782 {
6783  unsigned short cmd;
6784  int cnt;
6785  BYTES bytes;
6786 
6787  init_waitqueue_head(&j->poll_q);
6788  init_waitqueue_head(&j->read_q);
6789  init_waitqueue_head(&j->write_q);
6790 
6791  while(atomic_read(&j->DSPWrite) > 0)
6792  atomic_dec(&j->DSPWrite);
6793  if (ixjdebug & 0x0002)
6794  printk(KERN_INFO "Write IDLE to Software Control Register\n");
6795  ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6796 
6797  if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6798  return -1;
6799 /* The read values of the SSR should be 0x00 for the IDLE command */
6800  if (j->ssr.low || j->ssr.high)
6801  return -1;
6802  if (ixjdebug & 0x0002)
6803  printk(KERN_INFO "Get Device ID Code\n");
6804  if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6805  return -1;
6806  j->dsp.low = j->ssr.low;
6807  j->dsp.high = j->ssr.high;
6808  if (ixjdebug & 0x0002)
6809  printk(KERN_INFO "Get Device Version Code\n");
6810  if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6811  return -1;
6812  j->ver.low = j->ssr.low;
6813  j->ver.high = j->ssr.high;
6814  if (!j->cardtype) {
6815  if (j->dsp.low == 0x21) {
6816  bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6817  outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6818 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6819  bytes.low = inb_p(j->XILINXbase + 0x02);
6820  if (bytes.low == bytes.high) /* Register is read only on */
6821  /* Internet PhoneJack Lite */
6822  {
6823  j->cardtype = QTI_PHONEJACK_LITE;
6824  if (!request_region(j->XILINXbase, 4, "ixj control")) {
6825  printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6826  return -1;
6827  }
6828  j->pld_slicw.pcib.e1 = 1;
6829  outb_p(j->pld_slicw.byte, j->XILINXbase);
6830  } else {
6831  j->cardtype = QTI_LINEJACK;
6832 
6833  if (!request_region(j->XILINXbase, 8, "ixj control")) {
6834  printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6835  return -1;
6836  }
6837  }
6838  } else if (j->dsp.low == 0x22) {
6839  j->cardtype = QTI_PHONEJACK_PCI;
6840  request_region(j->XILINXbase, 4, "ixj control");
6841  j->pld_slicw.pcib.e1 = 1;
6842  outb_p(j->pld_slicw.byte, j->XILINXbase);
6843  } else
6844  j->cardtype = QTI_PHONEJACK;
6845  } else {
6846  switch (j->cardtype) {
6847  case QTI_PHONEJACK:
6848  if (!j->dsp.low != 0x20) {
6849  j->dsp.high = 0x80;
6850  j->dsp.low = 0x20;
6851  ixj_WriteDSPCommand(0x3800, j);
6852  j->ver.low = j->ssr.low;
6853  j->ver.high = j->ssr.high;
6854  }
6855  break;
6856  case QTI_LINEJACK:
6857  if (!request_region(j->XILINXbase, 8, "ixj control")) {
6858  printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6859  return -1;
6860  }
6861  break;
6862  case QTI_PHONEJACK_LITE:
6863  case QTI_PHONEJACK_PCI:
6864  if (!request_region(j->XILINXbase, 4, "ixj control")) {
6865  printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6866  return -1;
6867  }
6868  j->pld_slicw.pcib.e1 = 1;
6869  outb_p(j->pld_slicw.byte, j->XILINXbase);
6870  break;
6871  case QTI_PHONECARD:
6872  break;
6873  }
6874  }
6875  if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6876  if (ixjdebug & 0x0002)
6877  printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6878  if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6879  return -1;
6880  if (ixjdebug & 0x0002)
6881  printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6882  if (j->cardtype == QTI_PHONEJACK) {
6883  cmd = 0x9FF2;
6884  } else {
6885  cmd = 0x9FF5;
6886  }
6887  if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6888  return -1;
6889  } else {
6890  if (set_base_frame(j, 30) != 30)
6891  return -1;
6892  if (ixjdebug & 0x0002)
6893  printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6894  if (j->cardtype == QTI_PHONECARD) {
6895  if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6896  return -1;
6897  }
6898  if (j->cardtype == QTI_LINEJACK) {
6899  if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6900  return -1;
6901  if (ixjdebug & 0x0002)
6902  printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6903  j->pld_clock.byte = 0;
6904  outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6905  }
6906  }
6907 
6908  if (j->dsp.low == 0x20) {
6909  if (ixjdebug & 0x0002)
6910  printk(KERN_INFO "Configure GPIO pins\n");
6911  j->gpio.bytes.high = 0x09;
6912 /* bytes.low = 0xEF; 0xF7 */
6913  j->gpio.bits.gpio1 = 1;
6914  j->gpio.bits.gpio2 = 1;
6915  j->gpio.bits.gpio3 = 0;
6916  j->gpio.bits.gpio4 = 1;
6917  j->gpio.bits.gpio5 = 1;
6918  j->gpio.bits.gpio6 = 1;
6919  j->gpio.bits.gpio7 = 1;
6920  ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6921  if (ixjdebug & 0x0002)
6922  printk(KERN_INFO "Enable SLIC\n");
6923  j->gpio.bytes.high = 0x0B;
6924  j->gpio.bytes.low = 0x00;
6925  j->gpio.bits.gpio1 = 0;
6926  j->gpio.bits.gpio2 = 1;
6927  j->gpio.bits.gpio5 = 0;
6928  ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6929  j->port = PORT_POTS;
6930  } else {
6931  if (j->cardtype == QTI_LINEJACK) {
6932  LED_SetState(0x1, j);
6933  msleep(100);
6934  LED_SetState(0x2, j);
6935  msleep(100);
6936  LED_SetState(0x4, j);
6937  msleep(100);
6938  LED_SetState(0x8, j);
6939  msleep(100);
6940  LED_SetState(0x0, j);
6941  daa_get_version(j);
6942  if (ixjdebug & 0x0002)
6943  printk("Loading DAA Coefficients\n");
6944  DAA_Coeff_US(j);
6945  if (!ixj_daa_write(j)) {
6946  printk("DAA write failed on board %d\n", j->board);
6947  return -1;
6948  }
6949  if(!ixj_daa_cid_reset(j)) {
6950  printk("DAA CID reset failed on board %d\n", j->board);
6951  return -1;
6952  }
6953  j->flags.pots_correct = 0;
6954  j->flags.pstn_present = 0;
6955  ixj_linetest(j);
6956  if (j->flags.pots_correct) {
6957  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6958 
6959  outb_p(j->pld_scrw.byte, j->XILINXbase);
6960  j->pld_slicw.bits.rly1 = 1;
6961  j->pld_slicw.bits.spken = 1;
6962  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6963  SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6964 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6965  j->port = PORT_POTS;
6966  }
6967  ixj_set_port(j, PORT_PSTN);
6968  ixj_set_pots(j, 1);
6969  if (ixjdebug & 0x0002)
6970  printk(KERN_INFO "Enable Mixer\n");
6971  ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6972  ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6973 
6974  ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6975  ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6976 
6977  ixj_mixer(0x0480, j); /*FM Left mute */
6978  ixj_mixer(0x0580, j); /*FM Right mute */
6979 
6980  ixj_mixer(0x0680, j); /*CD Left mute */
6981  ixj_mixer(0x0780, j); /*CD Right mute */
6982 
6983  ixj_mixer(0x0880, j); /*Line Left mute */
6984  ixj_mixer(0x0980, j); /*Line Right mute */
6985 
6986  ixj_mixer(0x0A80, j); /*Aux left mute */
6987  ixj_mixer(0x0B80, j); /*Aux right mute */
6988 
6989  ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6990  ixj_mixer(0x0D80, j); /*Mono2 mute */
6991 
6992  ixj_mixer(0x0E80, j); /*Mic mute */
6993 
6994  ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6995 
6996  ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6997  ixj_mixer(0x110C, j);
6998 
6999 
7000  ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
7001  ixj_mixer(0x1401, j);
7002 
7003  ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
7004  ixj_mixer(0x1501, j);
7005 
7006  ixj_mixer(0x1700, j); /*Clock select */
7007 
7008  ixj_mixer(0x1800, j); /*ADC input from mixer */
7009 
7010  ixj_mixer(0x1901, j); /*Mic gain 30db */
7011 
7012  if (ixjdebug & 0x0002)
7013  printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7014  j->cadence_f[4].state = 0;
7015  j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7016  j->cadence_f[4].off1 = 0;
7017  j->cadence_f[4].on2 = 0;
7018  j->cadence_f[4].off2 = 0;
7019  j->cadence_f[4].on3 = 0;
7020  j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7021  j->pstn_last_rmr = jiffies;
7022 
7023  } else {
7024  if (j->cardtype == QTI_PHONECARD) {
7025  ixj_WriteDSPCommand(0xCF07, j);
7026  ixj_WriteDSPCommand(0x00B0, j);
7027  ixj_set_port(j, PORT_SPEAKER);
7028  } else {
7029  ixj_set_port(j, PORT_POTS);
7030  SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7031 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7032  }
7033  }
7034  }
7035 
7036  j->intercom = -1;
7037  j->framesread = j->frameswritten = 0;
7038  j->read_wait = j->write_wait = 0;
7039  j->rxreadycheck = j->txreadycheck = 0;
7040 
7041  /* initialise the DTMF prescale to a sensible value */
7042  if (j->cardtype == QTI_LINEJACK) {
7043  set_dtmf_prescale(j, 0x10);
7044  } else {
7045  set_dtmf_prescale(j, 0x40);
7046  }
7047  set_play_volume(j, 0x100);
7048  set_rec_volume(j, 0x100);
7049 
7050  if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7051  return -1;
7052 /* The read values of the SSR should be 0x00 for the IDLE command */
7053  if (j->ssr.low || j->ssr.high)
7054  return -1;
7055 
7056  if (ixjdebug & 0x0002)
7057  printk(KERN_INFO "Enable Line Monitor\n");
7058 
7059  if (ixjdebug & 0x0002)
7060  printk(KERN_INFO "Set Line Monitor to Asynchronous Mode\n");
7061 
7062  if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7063  return -1;
7064 
7065  if (ixjdebug & 0x002)
7066  printk(KERN_INFO "Enable DTMF Detectors\n");
7067 
7068  if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7069  return -1;
7070 
7071  if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asynchronous Tone Generation */
7072  return -1;
7073 
7074  set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7075 
7076  set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7077 
7078  j->ex.bits.dtmf_ready = 0;
7079  j->dtmf_state = 0;
7080  j->dtmf_wp = j->dtmf_rp = 0;
7081  j->rec_mode = j->play_mode = -1;
7082  j->flags.ringing = 0;
7083  j->maxrings = MAXRINGS;
7084  j->ring_cadence = USA_RING_CADENCE;
7085  j->drybuffer = 0;
7086  j->winktime = 320;
7087  j->flags.dtmf_oob = 0;
7088  for (cnt = 0; cnt < 4; cnt++)
7089  j->cadence_f[cnt].enable = 0;
7090  /* must be a device on the specified address */
7091  ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7092 
7093  /* Set up the default signals for events */
7094  for (cnt = 0; cnt < 35; cnt++)
7095  j->ixj_signals[cnt] = SIGIO;
7096 
7097  /* Set the exception signal enable flags */
7098  j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7099  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 =
7100  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;
7101 #ifdef IXJ_DYN_ALLOC
7102  j->fskdata = NULL;
7103 #endif
7104  j->fskdcnt = 0;
7105  j->cidcw_wait = 0;
7106 
7107  /* Register with the Telephony for Linux subsystem */
7108  j->p.f_op = &ixj_fops;
7109  j->p.open = ixj_open;
7110  j->p.board = j->board;
7111  phone_register_device(&j->p, PHONE_UNIT_ANY);
7112 
7113  ixj_init_timer(j);
7114  ixj_add_timer(j);
7115  return 0;
7116 }
7117 
7118 /*
7119  * Exported service for pcmcia card handling
7120  */
7121 
7122 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7123 {
7124  IXJ *j = ixj_alloc();
7125 
7126  j->board = 0;
7127 
7128  j->DSPbase = dsp;
7129  j->XILINXbase = xilinx;
7130  j->cardtype = QTI_PHONECARD;
7131  ixj_selfprobe(j);
7132  return j;
7133 }
7134 
7135 EXPORT_SYMBOL(ixj_pcmcia_probe); /* For PCMCIA */
7136 
7137 static int ixj_get_status_proc(char *buf)
7138 {
7139  int len;
7140  int cnt;
7141  IXJ *j;
7142  len = 0;
7143  len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7144  len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7145  len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7146  len += sprintf(buf + len, "\nUsing old telephony API");
7147  len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7148 
7149  for (cnt = 0; cnt < IXJMAX; cnt++) {
7150  j = get_ixj(cnt);
7151  if(j==NULL)
7152  continue;
7153  if (j->DSPbase) {
7154  len += sprintf(buf + len, "\nCard Num %d", cnt);
7155  len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7156  if (j->cardtype != QTI_PHONEJACK)
7157  len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7158  len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7159  len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7160  len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7161  switch (j->cardtype) {
7162  case (QTI_PHONEJACK):
7163  len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7164  break;
7165  case (QTI_LINEJACK):
7166  len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7167  if (j->flags.g729_loaded)
7168  len += sprintf(buf + len, " w/G.729 A/B");
7169  len += sprintf(buf + len, " Country = %d", j->daa_country);
7170  break;
7171  case (QTI_PHONEJACK_LITE):
7172  len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7173  if (j->flags.g729_loaded)
7174  len += sprintf(buf + len, " w/G.729 A/B");
7175  break;
7176  case (QTI_PHONEJACK_PCI):
7177  len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7178  if (j->flags.g729_loaded)
7179  len += sprintf(buf + len, " w/G.729 A/B");
7180  break;
7181  case (QTI_PHONECARD):
7182  len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7183  if (j->flags.g729_loaded)
7184  len += sprintf(buf + len, " w/G.729 A/B");
7185  len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7186  if (!j->pccr1.bits.drf)
7187  len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7188  len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7189  break;
7190  default:
7191  len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7192  break;
7193  }
7194  len += sprintf(buf + len, "\nReaders %d", j->readers);
7195  len += sprintf(buf + len, "\nWriters %d", j->writers);
7196  add_caps(j);
7197  len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7198  if (j->dsp.low != 0x20)
7199  len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7200  if (j->flags.cidsent)
7201  len += sprintf(buf + len, "\nCaller ID data sent");
7202  else
7203  len += sprintf(buf + len, "\nCaller ID data not sent");
7204 
7205  len += sprintf(buf + len, "\nPlay CODEC ");
7206  switch (j->play_codec) {
7207  case G723_63:
7208  len += sprintf(buf + len, "G.723.1 6.3");
7209  break;
7210  case G723_53:
7211  len += sprintf(buf + len, "G.723.1 5.3");
7212  break;
7213  case TS85:
7214  len += sprintf(buf + len, "TrueSpeech 8.5");
7215  break;
7216  case TS48:
7217  len += sprintf(buf + len, "TrueSpeech 4.8");
7218  break;
7219  case TS41:
7220  len += sprintf(buf + len, "TrueSpeech 4.1");
7221  break;
7222  case G728:
7223  len += sprintf(buf + len, "G.728");
7224  break;
7225  case G729:
7226  len += sprintf(buf + len, "G.729");
7227  break;
7228  case G729B:
7229  len += sprintf(buf + len, "G.729B");
7230  break;
7231  case ULAW:
7232  len += sprintf(buf + len, "uLaw");
7233  break;
7234  case ALAW:
7235  len += sprintf(buf + len, "aLaw");
7236  break;
7237  case LINEAR16:
7238  len += sprintf(buf + len, "16 bit Linear");
7239  break;
7240  case LINEAR8:
7241  len += sprintf(buf + len, "8 bit Linear");
7242  break;
7243  case WSS:
7244  len += sprintf(buf + len, "Windows Sound System");
7245  break;
7246  default:
7247  len += sprintf(buf + len, "NO CODEC CHOSEN");
7248  break;
7249  }
7250  len += sprintf(buf + len, "\nRecord CODEC ");
7251  switch (j->rec_codec) {
7252  case G723_63:
7253  len += sprintf(buf + len, "G.723.1 6.3");
7254  break;
7255  case G723_53:
7256  len += sprintf(buf + len, "G.723.1 5.3");
7257  break;
7258  case TS85:
7259  len += sprintf(buf + len, "TrueSpeech 8.5");
7260  break;
7261  case TS48:
7262  len += sprintf(buf + len, "TrueSpeech 4.8");
7263  break;
7264  case TS41:
7265  len += sprintf(buf + len, "TrueSpeech 4.1");
7266  break;
7267  case G728:
7268  len += sprintf(buf + len, "G.728");
7269  break;
7270  case G729:
7271  len += sprintf(buf + len, "G.729");
7272  break;
7273  case G729B:
7274  len += sprintf(buf + len, "G.729B");
7275  break;
7276  case ULAW:
7277  len += sprintf(buf + len, "uLaw");
7278  break;
7279  case ALAW:
7280  len += sprintf(buf + len, "aLaw");
7281  break;
7282  case LINEAR16:
7283  len += sprintf(buf + len, "16 bit Linear");
7284  break;
7285  case LINEAR8:
7286  len += sprintf(buf + len, "8 bit Linear");
7287  break;
7288  case WSS:
7289  len += sprintf(buf + len, "Windows Sound System");
7290  break;
7291  default:
7292  len += sprintf(buf + len, "NO CODEC CHOSEN");
7293  break;
7294  }
7295  len += sprintf(buf + len, "\nAEC ");
7296  switch (j->aec_level) {
7297  case AEC_OFF:
7298  len += sprintf(buf + len, "Off");
7299  break;
7300  case AEC_LOW:
7301  len += sprintf(buf + len, "Low");
7302  break;
7303  case AEC_MED:
7304  len += sprintf(buf + len, "Med");
7305  break;
7306  case AEC_HIGH:
7307  len += sprintf(buf + len, "High");
7308  break;
7309  case AEC_AUTO:
7310  len += sprintf(buf + len, "Auto");
7311  break;
7312  case AEC_AGC:
7313  len += sprintf(buf + len, "AEC/AGC");
7314  break;
7315  default:
7316  len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7317  break;
7318  }
7319 
7320  len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7321  len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7322  len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7323 
7324  len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7325 
7326  if (j->cardtype == QTI_LINEJACK) {
7327  len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7328  len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7329  len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7330  len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7331  switch (j->daa_mode) {
7332  case SOP_PU_SLEEP:
7333  len += sprintf(buf + len, "\nDAA PSTN On Hook");
7334  break;
7335  case SOP_PU_RINGING:
7336  len += sprintf(buf + len, "\nDAA PSTN Ringing");
7337  len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7338  break;
7339  case SOP_PU_CONVERSATION:
7340  len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7341  break;
7342  case SOP_PU_PULSEDIALING:
7343  len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7344  break;
7345  }
7346  len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7347  len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7348  len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7349  len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7350  len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7351  len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7352  len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7353  len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7354  len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7355  len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7356  }
7357  switch (j->port) {
7358  case PORT_POTS:
7359  len += sprintf(buf + len, "\nPort POTS");
7360  break;
7361  case PORT_PSTN:
7362  len += sprintf(buf + len, "\nPort PSTN");
7363  break;
7364  case PORT_SPEAKER:
7365  len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7366  break;
7367  case PORT_HANDSET:
7368  len += sprintf(buf + len, "\nPort HANDSET");
7369  break;
7370  }
7371  if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7372  len += sprintf(buf + len, "\nSLIC state ");
7373  switch (SLIC_GetState(j)) {
7374  case PLD_SLIC_STATE_OC:
7375  len += sprintf(buf + len, "OC");
7376  break;
7377  case PLD_SLIC_STATE_RINGING:
7378  len += sprintf(buf + len, "RINGING");
7379  break;
7380  case PLD_SLIC_STATE_ACTIVE:
7381  len += sprintf(buf + len, "ACTIVE");
7382  break;
7383  case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7384  len += sprintf(buf + len, "OHT");
7385  break;
7386  case PLD_SLIC_STATE_TIPOPEN:
7387  len += sprintf(buf + len, "TIPOPEN");
7388  break;
7389  case PLD_SLIC_STATE_STANDBY:
7390  len += sprintf(buf + len, "STANDBY");
7391  break;
7392  case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7393  len += sprintf(buf + len, "APR");
7394  break;
7395  case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7396  len += sprintf(buf + len, "OHTPR");
7397  break;
7398  default:
7399  len += sprintf(buf + len, "%d", SLIC_GetState(j));
7400  break;
7401  }
7402  }
7403  len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7404  len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7405 #ifdef PERFMON_STATS
7406  len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7407  len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7408  len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7409  len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7410  len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7411  len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7412  len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7413  len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7414  len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7415  len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7416  len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7417  len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7418  len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7419  len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7420 
7421 #endif
7422  len += sprintf(buf + len, "\n");
7423  }
7424  }
7425  return len;
7426 }
7427 
7428 static int ixj_read_proc(char *page, char **start, off_t off,
7429  int count, int *eof, void *data)
7430 {
7431  int len = ixj_get_status_proc(page);
7432  if (len <= off+count) *eof = 1;
7433  *start = page + off;
7434  len -= off;
7435  if (len>count) len = count;
7436  if (len<0) len = 0;
7437  return len;
7438 }
7439 
7440 
7441 static void cleanup(void)
7442 {
7443  int cnt;
7444  IXJ *j;
7445 
7446  for (cnt = 0; cnt < IXJMAX; cnt++) {
7447  j = get_ixj(cnt);
7448  if(j != NULL && j->DSPbase) {
7449  if (ixjdebug & 0x0002)
7450  printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7451  del_timer(&j->timer);
7452  if (j->cardtype == QTI_LINEJACK) {
7453  j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7454 
7455  outb_p(j->pld_scrw.byte, j->XILINXbase);
7456  j->pld_slicw.bits.rly1 = 0;
7457  j->pld_slicw.bits.rly2 = 0;
7458  j->pld_slicw.bits.rly3 = 0;
7459  outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7460  LED_SetState(0x0, j);
7461  if (ixjdebug & 0x0002)
7462  printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7463  release_region(j->XILINXbase, 8);
7464  } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7465  if (ixjdebug & 0x0002)
7466  printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7467  release_region(j->XILINXbase, 4);
7468  }
7469  kfree(j->read_buffer);
7470  kfree(j->write_buffer);
7471  if (j->dev)
7472  pnp_device_detach(j->dev);
7473  if (ixjdebug & 0x0002)
7474  printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7475  phone_unregister_device(&j->p);
7476  if (ixjdebug & 0x0002)
7477  printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7478  release_region(j->DSPbase, 16);
7479 #ifdef IXJ_DYN_ALLOC
7480  if (ixjdebug & 0x0002)
7481  printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7482  kfree(j);
7483  ixj[cnt] = NULL;
7484 #endif
7485  }
7486  }
7487  if (ixjdebug & 0x0002)
7488  printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7489  remove_proc_entry ("ixj", NULL);
7490 }
7491 
7492 /* Typedefs */
7493 typedef struct {
7494  BYTE length;
7495  DWORD bits;
7496 } DATABLOCK;
7497 
7498 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7499 {
7500  lastLCC = lastLCC & 0xfb;
7501  lastLCC = lastLCC | (byData ? 4 : 0);
7502  outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7503 
7504  mdelay(1);
7505  lastLCC = lastLCC | 0x01;
7506  outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7507 
7508  byData = byData << 1;
7509  lastLCC = lastLCC & 0xfe;
7510  mdelay(1);
7511  outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7512 
7513 }
7514 
7515 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7516 {
7517  mdelay(1);
7518  lastLCC = lastLCC | 0x01;
7519  outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7520 
7521  lastLCC = lastLCC & 0xfe;
7522  mdelay(1);
7523  outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7524 
7525  return ((inb(wEEPROMAddress) >> 3) & 1);
7526 }
7527 
7528 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7529 {
7530  BYTE lastLCC;
7531  WORD wEEPROMAddress = wAddress + 3;
7532  DWORD i;
7533  BYTE byResult;
7534  *pwResult = 0;
7535  lastLCC = inb(wEEPROMAddress);
7536  lastLCC = lastLCC | 0x02;
7537  lastLCC = lastLCC & 0xfe;
7538  outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7539 
7540  mdelay(1); /* delay */
7541 
7542  PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7543  PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7544  PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7545  for (i = 0; i < 8; i++) {
7546  PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7547  wLoc <<= 1;
7548  }
7549 
7550  for (i = 0; i < 16; i++) {
7551  byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7552  *pwResult = (*pwResult << 1) | byResult;
7553  }
7554 
7555  mdelay(1); /* another delay */
7556 
7557  lastLCC = lastLCC & 0xfd;
7558  outb(lastLCC, wEEPROMAddress); /* negate CS */
7559 
7560  return 0;
7561 }
7562 
7563 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7564 {
7565  WORD wLo, wHi;
7566  if (PCIEE_ReadWord(wAddress, 62, &wLo))
7567  return 0;
7568  if (PCIEE_ReadWord(wAddress, 63, &wHi))
7569  return 0;
7570  return (((DWORD) wHi << 16) | wLo);
7571 }
7572 
7573 static int dspio[IXJMAX + 1] =
7574 {
7575  0,
7576 };
7577 static int xio[IXJMAX + 1] =
7578 {
7579  0,
7580 };
7581 
7582 module_param_array(dspio, int, NULL, 0);
7583 module_param_array(xio, int, NULL, 0);
7584 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7585 MODULE_AUTHOR("Ed Okerson <[email protected]>");
7586 MODULE_LICENSE("GPL");
7587 
7588 static void __exit ixj_exit(void)
7589 {
7590  cleanup();
7591 }
7592 
7593 static IXJ *new_ixj(unsigned long port)
7594 {
7595  IXJ *res;
7596  if (!request_region(port, 16, "ixj DSP")) {
7597  printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7598  return NULL;
7599  }
7600  res = ixj_alloc();
7601  if (!res) {
7602  release_region(port, 16);
7603  printk(KERN_INFO "ixj: out of memory\n");
7604  return NULL;
7605  }
7606  res->DSPbase = port;
7607  return res;
7608 }
7609 
7610 static int __init ixj_probe_isapnp(int *cnt)
7611 {
7612  int probe = 0;
7613  int func = 0x110;
7614  struct pnp_dev *dev = NULL, *old_dev = NULL;
7615 
7616  while (1) {
7617  do {
7618  IXJ *j;
7619  int result;
7620 
7621  old_dev = dev;
7622  dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7623  ISAPNP_FUNCTION(func), old_dev);
7624  if (!dev || !dev->card)
7625  break;
7626  result = pnp_device_attach(dev);
7627  if (result < 0) {
7628  printk("pnp attach failed %d \n", result);
7629  break;
7630  }
7631  if (pnp_activate_dev(dev) < 0) {
7632  printk("pnp activate failed (out of resources?)\n");
7633  pnp_device_detach(dev);
7634  return -ENOMEM;
7635  }
7636 
7637  if (!pnp_port_valid(dev, 0)) {
7638  pnp_device_detach(dev);
7639  return -ENODEV;
7640  }
7641 
7642  j = new_ixj(pnp_port_start(dev, 0));
7643  if (!j)
7644  break;
7645 
7646  if (func != 0x110)
7647  j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7648 
7649  switch (func) {
7650  case (0x110):
7651  j->cardtype = QTI_PHONEJACK;
7652  break;
7653  case (0x310):
7654  j->cardtype = QTI_LINEJACK;
7655  break;
7656  case (0x410):
7657  j->cardtype = QTI_PHONEJACK_LITE;
7658  break;
7659  }
7660  j->board = *cnt;
7661  probe = ixj_selfprobe(j);
7662  if(!probe) {
7663  j->serial = dev->card->serial;
7664  j->dev = dev;
7665  switch (func) {
7666  case 0x110:
7667  printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7668  break;
7669  case 0x310:
7670  printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7671  break;
7672  case 0x410:
7673  printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7674  break;
7675  }
7676  }
7677  ++*cnt;
7678  } while (dev);
7679  if (func == 0x410)
7680  break;
7681  if (func == 0x310)
7682  func = 0x410;
7683  if (func == 0x110)
7684  func = 0x310;
7685  dev = NULL;
7686  }
7687  return probe;
7688 }
7689 
7690 static int __init ixj_probe_isa(int *cnt)
7691 {
7692  int i, probe;
7693 
7694  /* Use passed parameters for older kernels without PnP */
7695  for (i = 0; i < IXJMAX; i++) {
7696  if (dspio[i]) {
7697  IXJ *j = new_ixj(dspio[i]);
7698 
7699  if (!j)
7700  break;
7701 
7702  j->XILINXbase = xio[i];
7703  j->cardtype = 0;
7704 
7705  j->board = *cnt;
7706  probe = ixj_selfprobe(j);
7707  j->dev = NULL;
7708  ++*cnt;
7709  }
7710  }
7711  return 0;
7712 }
7713 
7714 static int __init ixj_probe_pci(int *cnt)
7715 {
7716  struct pci_dev *pci = NULL;
7717  int i, probe = 0;
7718  IXJ *j = NULL;
7719 
7720  for (i = 0; i < IXJMAX - *cnt; i++) {
7721  pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7722  PCI_DEVICE_ID_QUICKNET_XJ, pci);
7723  if (!pci)
7724  break;
7725 
7726  if (pci_enable_device(pci))
7727  break;
7728  j = new_ixj(pci_resource_start(pci, 0));
7729  if (!j)
7730  break;
7731 
7732  j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7733  j->XILINXbase = j->DSPbase + 0x10;
7734  j->cardtype = QTI_PHONEJACK_PCI;
7735  j->board = *cnt;
7736  probe = ixj_selfprobe(j);
7737  if (!probe)
7738  printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7739  ++*cnt;
7740  }
7741  pci_dev_put(pci);
7742  return probe;
7743 }
7744 
7745 static int __init ixj_init(void)
7746 {
7747  int cnt = 0;
7748  int probe = 0;
7749 
7750  cnt = 0;
7751 
7752  /* These might be no-ops, see above. */
7753  if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7754  return probe;
7755  }
7756  if ((probe = ixj_probe_isa(&cnt)) < 0) {
7757  return probe;
7758  }
7759  if ((probe = ixj_probe_pci(&cnt)) < 0) {
7760  return probe;
7761  }
7762  printk(KERN_INFO "ixj driver initialized.\n");
7763  create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7764  return probe;
7765 }
7766 
7767 module_init(ixj_init);
7768 module_exit(ixj_exit);
7769 
7770 static void DAA_Coeff_US(IXJ *j)
7771 {
7772  int i;
7773 
7774  j->daa_country = DAA_US;
7775  /*----------------------------------------------- */
7776  /* CAO */
7777  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7778  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7779  }
7780 
7781 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7782  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7783  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7784  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7785  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7786  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7787  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7788  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7789  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7790 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7791  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7792  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7793  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7794  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7795  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7796  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7797  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7798  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7799 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7800  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7801  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7802  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7803  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7804  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7805  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7806  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7807  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7808 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7809  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7810  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7811  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7812  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7813  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7814  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7815  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7816  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7817 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7818  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7819  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7820  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7821  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7822 /* Bytes for AR-filter (09): 52,D3,11,42 */
7823  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7824  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7825  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7826  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7827 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7828  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7829  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7830  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7831  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7832  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7833  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7834  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7835  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7836 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7837  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7838  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7839  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7840  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7841  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7842  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7843  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7844  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7845 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7846  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7847  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7848  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7849  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7850  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7851  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7852  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7853  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7854 /* ; (10K, 0.68uF) */
7855  /* */
7856  /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7857  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7858  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7859  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7860  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7861  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7862  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7863  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7864  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7865  /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7866  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7867  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7868  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7869  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7870  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7871  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7872  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7873  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7874 
7875  /* Levelmetering Ringing (0D):B2,45,0F,8E */
7876  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7877  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7878  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7879  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7880 
7881  /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7884 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7885 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7886 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7887 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7888 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7889 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7890  /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7891 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7892 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7893 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7894 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7895 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7896 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7897 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7898 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7899 /* */
7900  /* Levelmetering Ringing (0D):B2,45,0F,8E */
7901 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7902 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7903 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7904 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7905 
7906  /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7907  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7908  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7909  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7910  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7911  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7912  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7913  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7914  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7915 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7916  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7917  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7918  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7919  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7920  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7921  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7922  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7923  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7924 /* */
7925  /* ;CR Registers */
7926  /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7927  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7928 /* Config. Reg. 1 (dialing) (cr1):05 */
7929  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7930 /* Config. Reg. 2 (caller ID) (cr2):04 */
7931  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7932 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7933  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7934 /* Config. Reg. 4 (analog gain) (cr4):02 */
7935  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7936  /* Config. Reg. 5 (Version) (cr5):02 */
7937  /* Config. Reg. 6 (Reserved) (cr6):00 */
7938  /* Config. Reg. 7 (Reserved) (cr7):00 */
7939  /* */
7940  /* ;xr Registers */
7941  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7942 
7943  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7944  /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7945 
7946  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7947 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7948  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7949 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7950  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7951  /* Ext. Reg. 4 (Cadence) (xr4):00 */
7952 
7953  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7954 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7955  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7956 /* Ext. Reg. 6 (Power State) (xr6):00 */
7957  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7958 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7959  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7960  /* */
7961  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7962  /* 12,33,5A,C3 ; 770 Hz */
7963  /* 13,3C,5B,32 ; 852 Hz */
7964  /* 1D,1B,5C,CC ; 941 Hz */
7965 
7966  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7967  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7968  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7969  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7970 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7971  /* EC,1D,52,22 ; 1336 Hz */
7972  /* AA,AC,51,D2 ; 1477 Hz */
7973  /* 9B,3B,51,25 ; 1633 Hz */
7974  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7975  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7976  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7977  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7978 }
7979 
7980 static void DAA_Coeff_UK(IXJ *j)
7981 {
7982  int i;
7983 
7984  j->daa_country = DAA_UK;
7985  /*----------------------------------------------- */
7986  /* CAO */
7987  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7988  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7989  }
7990 
7991 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7992  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7993  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7994  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7995  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7996  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7997  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7998  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7999  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8000 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8001  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8002  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8003  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8004  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8005  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8006  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8007  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8008  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8009 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
8010  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8011  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8012  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8013  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8014  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8015  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8016  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8017  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8018 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8019  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8020  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8021  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8022  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8023  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8024  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8025  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8026  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8027 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8028  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8029  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8030  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8031  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8032 /* Bytes for AR-filter (09): E2,27,10,D6 */
8033  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8034  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8035  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8036  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8037 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8038  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8039  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8040  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8041  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8042  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8043  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8044  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8045  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8046 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8047  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8048  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8049  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8050  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8051  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8052  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8053  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8054  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8055 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8056  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8057  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8058  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8059  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8060  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8061  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8062  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8063  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8064 /* ; idle */
8065  /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8066  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8067  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8068  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8069  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8070  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8071  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8072  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8073  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8074 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8075  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8076  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8077  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8078  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8079  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8080  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8081  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8082  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8083 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8084  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8085  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8086  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8087  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8088 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8089  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8090  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8091  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8092  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8093  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8094  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8095  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8096  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8097 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8098  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8099  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8100  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8101  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8102  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8103  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8104  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8105  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8106 /* ;CR Registers */
8107  /* Config. Reg. 0 (filters) (cr0):FF */
8108  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8109 /* Config. Reg. 1 (dialing) (cr1):05 */
8110  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8111 /* Config. Reg. 2 (caller ID) (cr2):04 */
8112  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8113 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8114  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8115 /* Config. Reg. 4 (analog gain) (cr4):02 */
8116  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8117  /* Config. Reg. 5 (Version) (cr5):02 */
8118  /* Config. Reg. 6 (Reserved) (cr6):00 */
8119  /* Config. Reg. 7 (Reserved) (cr7):00 */
8120  /* ;xr Registers */
8121  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8122 
8123  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8124  /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8125 
8126  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8127  /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8128 
8129  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8130 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8131  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8132 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8133  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8134 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8135  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8136 /* Ext. Reg. 6 (Power State) (xr6):00 */
8137  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8138 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8139  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8140  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8141  /* 12,33,5A,C3 ; 770 Hz */
8142  /* 13,3C,5B,32 ; 852 Hz */
8143  /* 1D,1B,5C,CC ; 941 Hz */
8144 
8145  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8146  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8147  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8148  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8149 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8150  /* EC,1D,52,22 ; 1336 Hz */
8151  /* AA,AC,51,D2 ; 1477 Hz */
8152  /* 9B,3B,51,25 ; 1633 Hz */
8153  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8154  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8155  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8156  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8157 }
8158 
8159 
8160 static void DAA_Coeff_France(IXJ *j)
8161 {
8162  int i;
8163 
8164  j->daa_country = DAA_FRANCE;
8165  /*----------------------------------------------- */
8166  /* CAO */
8167  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8168  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8169  }
8170 
8171 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8172  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8173  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8174  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8175  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8176  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8177  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8178  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8179  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8180 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8181  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8182  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8183  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8184  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8185  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8186  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8187  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8188  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8189 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8190  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8191  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8192  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8193  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8194  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8195  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8196  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8197  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8198 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8199  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8200  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8201  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8202  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8203  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8204  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8205  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8206  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8207 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8208  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8209  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8210  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8211  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8212 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8213  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8214  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8215  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8216  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8217 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8218  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8219  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8220  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8221  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8222  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8223  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8224  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8225  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8226 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8227  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8228  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8229  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8230  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8231  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8232  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8233  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8234  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8235 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8236  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8237  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8238  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8239  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8240  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8241  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8242  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8243  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8244 /* ; idle */
8245  /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8246  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8247  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8248  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8249  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8250  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8251  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8252  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8253  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8254 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8255  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8256  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8257  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8258  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8259  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8260  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8261  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8262  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8263 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8264  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8265  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8266  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8267  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8268 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8269  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8270  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8271  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8272  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8273  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8274  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8275  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8276  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8277 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8278  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8279  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8280  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8281  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8282  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8283  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8284  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8285  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8286 /* ;CR Registers */
8287  /* Config. Reg. 0 (filters) (cr0):FF */
8288  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8289 /* Config. Reg. 1 (dialing) (cr1):05 */
8290  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8291 /* Config. Reg. 2 (caller ID) (cr2):04 */
8292  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8293 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8294  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8295 /* Config. Reg. 4 (analog gain) (cr4):02 */
8296  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8297  /* Config. Reg. 5 (Version) (cr5):02 */
8298  /* Config. Reg. 6 (Reserved) (cr6):00 */
8299  /* Config. Reg. 7 (Reserved) (cr7):00 */
8300  /* ;xr Registers */
8301  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8302 
8303  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8304  /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8305 
8306  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8307  /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8308 
8309  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8310 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8311  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8312 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8313  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8314 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8315  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8316 /* Ext. Reg. 6 (Power State) (xr6):00 */
8317  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8318 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8319  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8320  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8321  /* 12,33,5A,C3 ; 770 Hz */
8322  /* 13,3C,5B,32 ; 852 Hz */
8323  /* 1D,1B,5C,CC ; 941 Hz */
8324 
8325  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8326  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8327  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8328  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8329 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8330  /* EC,1D,52,22 ; 1336 Hz */
8331  /* AA,AC,51,D2 ; 1477 Hz */
8332  /* 9B,3B,51,25 ; 1633 Hz */
8333  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8334  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8335  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8336  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8337 }
8338 
8339 
8340 static void DAA_Coeff_Germany(IXJ *j)
8341 {
8342  int i;
8343 
8344  j->daa_country = DAA_GERMANY;
8345  /*----------------------------------------------- */
8346  /* CAO */
8347  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8348  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8349  }
8350 
8351 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8352  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8353  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8354  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8355  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8356  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8357  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8358  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8359  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8360 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8361  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8362  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8363  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8364  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8365  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8366  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8367  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8368  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8369 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8370  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8371  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8372  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8373  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8374  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8375  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8376  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8377  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8378 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8379  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8380  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8381  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8382  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8383  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8384  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8385  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8386  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8387 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8388  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8389  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8390  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8391  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8392 /* Bytes for AR-filter (09): 72,42,13,4B */
8393  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8394  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8395  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8396  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8397 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8398  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8399  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8400  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8401  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8402  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8403  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8404  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8405  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8406 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8407  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8408  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8409  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8410  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8411  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8412  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8413  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8414  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8415 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8416  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8417  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8418  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8419  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8420  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8421  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8422  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8423  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8424 /* ; (10K, 0.68uF) */
8425  /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8426  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8427  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8428  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8429  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8430  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8431  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8432  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8433  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8434 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8435  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8436  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8437  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8438  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8439  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8440  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8441  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8442  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8443 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8444  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8445  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8446  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8447  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8448 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8449  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8450  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8451  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8452  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8453  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8454  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8455  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8456  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8457 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8458  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8459  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8460  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8461  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8462  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8463  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8464  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8465  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8466 /* ;CR Registers */
8467  /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8468  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8469 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8470  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8471 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8472  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8473 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8474  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8475 /* Config. Reg. 4 (analog gain) (cr4):02 */
8476  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8477  /* Config. Reg. 5 (Version) (cr5):02 */
8478  /* Config. Reg. 6 (Reserved) (cr6):00 */
8479  /* Config. Reg. 7 (Reserved) (cr7):00 */
8480  /* ;xr Registers */
8481  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8482 
8483  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8484  /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8485 
8486  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8487  /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8488 
8489  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8490 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8491  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8492 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8493  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8494 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8495  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8496 /* Ext. Reg. 6 (Power State) (xr6):00 */
8497  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8498 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8499  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8500  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8501  /* 12,33,5A,C3 ; 770 Hz */
8502  /* 13,3C,5B,32 ; 852 Hz */
8503  /* 1D,1B,5C,CC ; 941 Hz */
8504 
8505  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8506  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8507  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8508  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8509 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8510  /* EC,1D,52,22 ; 1336 Hz */
8511  /* AA,AC,51,D2 ; 1477 Hz */
8512  /* 9B,3B,51,25 ; 1633 Hz */
8513  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8514  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8515  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8516  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8517 }
8518 
8519 
8520 static void DAA_Coeff_Australia(IXJ *j)
8521 {
8522  int i;
8523 
8524  j->daa_country = DAA_AUSTRALIA;
8525  /*----------------------------------------------- */
8526  /* CAO */
8527  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8528  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8529  }
8530 
8531 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8532  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8533  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8534  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8535  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8536  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8537  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8538  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8539  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8540 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8541  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8542  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8543  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8544  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8545  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8546  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8547  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8548  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8549 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8550  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8551  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8552  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8553  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8554  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8555  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8556  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8557  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8558 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8559  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8560  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8561  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8562  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8563  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8564  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8565  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8566  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8567 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8568  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8569  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8570  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8571  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8572 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8573  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8574  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8575  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8576  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8577 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8578  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8579  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8580  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8581  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8582  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8583  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8584  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8585  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8586 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8587  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8588  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8589  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8590  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8591  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8592  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8593  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8594  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8595 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8596  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8597  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8598  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8599  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8600  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8601  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8602  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8603  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8604 /* ; idle */
8605  /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8606  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8607  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8608  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8609  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8610  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8611  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8612  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8613  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8614 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8615  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8616  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8617  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8618  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8619  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8620  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8621  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8622  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8623 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8624  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8625  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8626  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8627  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8628 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8629  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8630  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8631  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8632  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8633  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8634  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8635  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8636  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8637 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8638  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8639  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8640  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8641  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8642  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8643  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8644  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8645  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8646 /* ;CR Registers */
8647  /* Config. Reg. 0 (filters) (cr0):FF */
8648  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8649 /* Config. Reg. 1 (dialing) (cr1):05 */
8650  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8651 /* Config. Reg. 2 (caller ID) (cr2):04 */
8652  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8653 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8654  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8655 /* Config. Reg. 4 (analog gain) (cr4):02 */
8656  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8657  /* Config. Reg. 5 (Version) (cr5):02 */
8658  /* Config. Reg. 6 (Reserved) (cr6):00 */
8659  /* Config. Reg. 7 (Reserved) (cr7):00 */
8660  /* ;xr Registers */
8661  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8662 
8663  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8664  /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8665 
8666  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8667  /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8668 
8669  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8670 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8671  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8672 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8673  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8674 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8675  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8676 /* Ext. Reg. 6 (Power State) (xr6):00 */
8677  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8678 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8679  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8680 
8681  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8682  /* 12,33,5A,C3 ; 770 Hz */
8683  /* 13,3C,5B,32 ; 852 Hz */
8684  /* 1D,1B,5C,CC ; 941 Hz */
8685  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8686  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8687  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8688  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8689 
8690  /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8691  /* EC,1D,52,22 ; 1336 Hz */
8692  /* AA,AC,51,D2 ; 1477 Hz */
8693  /* 9B,3B,51,25 ; 1633 Hz */
8694  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8695  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8696  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8697  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8698 }
8699 
8700 static void DAA_Coeff_Japan(IXJ *j)
8701 {
8702  int i;
8703 
8704  j->daa_country = DAA_JAPAN;
8705  /*----------------------------------------------- */
8706  /* CAO */
8707  for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8708  j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8709  }
8710 
8711 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8712  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8713  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8714  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8715  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8716  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8717  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8718  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8719  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8720 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8721  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8722  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8723  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8724  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8725  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8726  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8727  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8728  j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8729 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8730  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8731  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8732  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8733  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8734  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8735  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8736  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8737  j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8738 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8739  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8740  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8741  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8742  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8743  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8744  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8745  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8746  j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8747 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8748  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8749  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8750  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8751  j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8752 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8753  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8754  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8755  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8756  j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8757 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8758  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8759  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8760  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8761  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8762  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8763  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8764  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8765  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8766 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8767  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8768  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8769  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8770  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8771  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8772  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8773  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8774  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8775 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8776  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8777  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8778  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8779  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8780  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8781  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8782  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8783  j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8784 /* ; idle */
8785  /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8786  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8787  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8788  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8789  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8790  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8791  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8792  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8793  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8794 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8795  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8796  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8797  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8798  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8799  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8800  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8801  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8802  j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8803 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8804  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8805  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8806  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8807  j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8808 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8809  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8810  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8811  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8812  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8813  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8814  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8815  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8816  j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8817 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8818  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8819  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8820  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8821  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8822  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8823  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8824  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8825  j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8826 /* ;CR Registers */
8827  /* Config. Reg. 0 (filters) (cr0):FF */
8828  j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8829 /* Config. Reg. 1 (dialing) (cr1):05 */
8830  j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8831 /* Config. Reg. 2 (caller ID) (cr2):04 */
8832  j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8833 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8834  j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8835 /* Config. Reg. 4 (analog gain) (cr4):02 */
8836  j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8837  /* Config. Reg. 5 (Version) (cr5):02 */
8838  /* Config. Reg. 6 (Reserved) (cr6):00 */
8839  /* Config. Reg. 7 (Reserved) (cr7):00 */
8840  /* ;xr Registers */
8841  /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8842 
8843  j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8844  /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8845 
8846  j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8847  /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8848 
8849  j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8850 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8851  j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8852 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8853  j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8854 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8855  j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8856 /* Ext. Reg. 6 (Power State) (xr6):00 */
8857  j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8858 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8859  j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8860  /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8861  /* 12,33,5A,C3 ; 770 Hz */
8862  /* 13,3C,5B,32 ; 852 Hz */
8863  /* 1D,1B,5C,CC ; 941 Hz */
8864 
8865  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8866  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8867  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8868  j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8869 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8870  /* EC,1D,52,22 ; 1336 Hz */
8871  /* AA,AC,51,D2 ; 1477 Hz */
8872  /* 9B,3B,51,25 ; 1633 Hz */
8873  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8874  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8875  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8876  j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8877 }
8878 
8879 static s16 tone_table[][19] =
8880 {
8881  { /* f20_50[] 11 */
8882  32538, /* A1 = 1.985962 */
8883  -32325, /* A2 = -0.986511 */
8884  -343, /* B2 = -0.010493 */
8885  0, /* B1 = 0 */
8886  343, /* B0 = 0.010493 */
8887  32619, /* A1 = 1.990906 */
8888  -32520, /* A2 = -0.992462 */
8889  19179, /* B2 = 0.585327 */
8890  -19178, /* B1 = -1.170593 */
8891  19179, /* B0 = 0.585327 */
8892  32723, /* A1 = 1.997314 */
8893  -32686, /* A2 = -0.997528 */
8894  9973, /* B2 = 0.304352 */
8895  -9955, /* B1 = -0.607605 */
8896  9973, /* B0 = 0.304352 */
8897  7, /* Internal filter scaling */
8898  159, /* Minimum in-band energy threshold */
8899  21, /* 21/32 in-band to broad-band ratio */
8900  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8901  },
8902  { /* f133_200[] 12 */
8903  32072, /* A1 = 1.95752 */
8904  -31896, /* A2 = -0.973419 */
8905  -435, /* B2 = -0.013294 */
8906  0, /* B1 = 0 */
8907  435, /* B0 = 0.013294 */
8908  32188, /* A1 = 1.9646 */
8909  -32400, /* A2 = -0.98877 */
8910  15139, /* B2 = 0.462036 */
8911  -14882, /* B1 = -0.908356 */
8912  15139, /* B0 = 0.462036 */
8913  32473, /* A1 = 1.981995 */
8914  -32524, /* A2 = -0.992584 */
8915  23200, /* B2 = 0.708008 */
8916  -23113, /* B1 = -1.410706 */
8917  23200, /* B0 = 0.708008 */
8918  7, /* Internal filter scaling */
8919  159, /* Minimum in-band energy threshold */
8920  21, /* 21/32 in-band to broad-band ratio */
8921  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8922  },
8923  { /* f300 13 */
8924  31769, /* A1 = -1.939026 */
8925  -32584, /* A2 = 0.994385 */
8926  -475, /* B2 = -0.014522 */
8927  0, /* B1 = 0.000000 */
8928  475, /* B0 = 0.014522 */
8929  31789, /* A1 = -1.940247 */
8930  -32679, /* A2 = 0.997284 */
8931  17280, /* B2 = 0.527344 */
8932  -16865, /* B1 = -1.029358 */
8933  17280, /* B0 = 0.527344 */
8934  31841, /* A1 = -1.943481 */
8935  -32681, /* A2 = 0.997345 */
8936  543, /* B2 = 0.016579 */
8937  -525, /* B1 = -0.032097 */
8938  543, /* B0 = 0.016579 */
8939  5, /* Internal filter scaling */
8940  159, /* Minimum in-band energy threshold */
8941  21, /* 21/32 in-band to broad-band ratio */
8942  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8943  },
8944  { /* f300_420[] 14 */
8945  30750, /* A1 = 1.876892 */
8946  -31212, /* A2 = -0.952515 */
8947  -804, /* B2 = -0.024541 */
8948  0, /* B1 = 0 */
8949  804, /* B0 = 0.024541 */
8950  30686, /* A1 = 1.872925 */
8951  -32145, /* A2 = -0.980988 */
8952  14747, /* B2 = 0.450043 */
8953  -13703, /* B1 = -0.836395 */
8954  14747, /* B0 = 0.450043 */
8955  31651, /* A1 = 1.931824 */
8956  -32321, /* A2 = -0.986389 */
8957  24425, /* B2 = 0.745422 */
8958  -23914, /* B1 = -1.459595 */
8959  24427, /* B0 = 0.745483 */
8960  7, /* Internal filter scaling */
8961  159, /* Minimum in-band energy threshold */
8962  21, /* 21/32 in-band to broad-band ratio */
8963  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8964  },
8965  { /* f330 15 */
8966  31613, /* A1 = -1.929565 */
8967  -32646, /* A2 = 0.996277 */
8968  -185, /* B2 = -0.005657 */
8969  0, /* B1 = 0.000000 */
8970  185, /* B0 = 0.005657 */
8971  31620, /* A1 = -1.929932 */
8972  -32713, /* A2 = 0.998352 */
8973  19253, /* B2 = 0.587585 */
8974  -18566, /* B1 = -1.133179 */
8975  19253, /* B0 = 0.587585 */
8976  31674, /* A1 = -1.933228 */
8977  -32715, /* A2 = 0.998413 */
8978  2575, /* B2 = 0.078590 */
8979  -2495, /* B1 = -0.152283 */
8980  2575, /* B0 = 0.078590 */
8981  5, /* Internal filter scaling */
8982  159, /* Minimum in-band energy threshold */
8983  21, /* 21/32 in-band to broad-band ratio */
8984  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8985  },
8986  { /* f300_425[] 16 */
8987  30741, /* A1 = 1.876282 */
8988  -31475, /* A2 = -0.960541 */
8989  -703, /* B2 = -0.021484 */
8990  0, /* B1 = 0 */
8991  703, /* B0 = 0.021484 */
8992  30688, /* A1 = 1.873047 */
8993  -32248, /* A2 = -0.984161 */
8994  14542, /* B2 = 0.443787 */
8995  -13523, /* B1 = -0.825439 */
8996  14542, /* B0 = 0.443817 */
8997  31494, /* A1 = 1.922302 */
8998  -32366, /* A2 = -0.987762 */
8999  21577, /* B2 = 0.658508 */
9000  -21013, /* B1 = -1.282532 */
9001  21577, /* B0 = 0.658508 */
9002  7, /* Internal filter scaling */
9003  159, /* Minimum in-band energy threshold */
9004  21, /* 21/32 in-band to broad-band ratio */
9005  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9006  },
9007  { /* f330_440[] 17 */
9008  30627, /* A1 = 1.869324 */
9009  -31338, /* A2 = -0.95636 */
9010  -843, /* B2 = -0.025749 */
9011  0, /* B1 = 0 */
9012  843, /* B0 = 0.025749 */
9013  30550, /* A1 = 1.864685 */
9014  -32221, /* A2 = -0.983337 */
9015  13594, /* B2 = 0.414886 */
9016  -12589, /* B1 = -0.768402 */
9017  13594, /* B0 = 0.414886 */
9018  31488, /* A1 = 1.921936 */
9019  -32358, /* A2 = -0.987518 */
9020  24684, /* B2 = 0.753296 */
9021  -24029, /* B1 = -1.466614 */
9022  24684, /* B0 = 0.753296 */
9023  7, /* Internal filter scaling */
9024  159, /* Minimum in-band energy threshold */
9025  21, /* 21/32 in-band to broad-band ratio */
9026  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9027  },
9028  { /* f340 18 */
9029  31546, /* A1 = -1.925476 */
9030  -32646, /* A2 = 0.996277 */
9031  -445, /* B2 = -0.013588 */
9032  0, /* B1 = 0.000000 */
9033  445, /* B0 = 0.013588 */
9034  31551, /* A1 = -1.925781 */
9035  -32713, /* A2 = 0.998352 */
9036  23884, /* B2 = 0.728882 */
9037  -22979, /* B1 = -1.402527 */
9038  23884, /* B0 = 0.728882 */
9039  31606, /* A1 = -1.929138 */
9040  -32715, /* A2 = 0.998413 */
9041  863, /* B2 = 0.026367 */
9042  -835, /* B1 = -0.050985 */
9043  863, /* B0 = 0.026367 */
9044  5, /* Internal filter scaling */
9045  159, /* Minimum in-band energy threshold */
9046  21, /* 21/32 in-band to broad-band ratio */
9047  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9048  },
9049  { /* f350_400[] 19 */
9050  31006, /* A1 = 1.892517 */
9051  -32029, /* A2 = -0.977448 */
9052  -461, /* B2 = -0.014096 */
9053  0, /* B1 = 0 */
9054  461, /* B0 = 0.014096 */
9055  30999, /* A1 = 1.892029 */
9056  -32487, /* A2 = -0.991455 */
9057  11325, /* B2 = 0.345612 */
9058  -10682, /* B1 = -0.651978 */
9059  11325, /* B0 = 0.345612 */
9060  31441, /* A1 = 1.919067 */
9061  -32526, /* A2 = -0.992615 */
9062  24324, /* B2 = 0.74231 */
9063  -23535, /* B1 = -1.436523 */
9064  24324, /* B0 = 0.74231 */
9065  7, /* Internal filter scaling */
9066  159, /* Minimum in-band energy threshold */
9067  21, /* 21/32 in-band to broad-band ratio */
9068  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9069  },
9070  { /* f350_440[] */
9071  30634, /* A1 = 1.869751 */
9072  -31533, /* A2 = -0.962341 */
9073  -680, /* B2 = -0.020782 */
9074  0, /* B1 = 0 */
9075  680, /* B0 = 0.020782 */
9076  30571, /* A1 = 1.865906 */
9077  -32277, /* A2 = -0.985016 */
9078  12894, /* B2 = 0.393524 */
9079  -11945, /* B1 = -0.729065 */
9080  12894, /* B0 = 0.393524 */
9081  31367, /* A1 = 1.91449 */
9082  -32379, /* A2 = -0.988129 */
9083  23820, /* B2 = 0.726929 */
9084  -23104, /* B1 = -1.410217 */
9085  23820, /* B0 = 0.726929 */
9086  7, /* Internal filter scaling */
9087  159, /* Minimum in-band energy threshold */
9088  21, /* 21/32 in-band to broad-band ratio */
9089  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9090  },
9091  { /* f350_450[] */
9092  30552, /* A1 = 1.864807 */
9093  -31434, /* A2 = -0.95929 */
9094  -690, /* B2 = -0.021066 */
9095  0, /* B1 = 0 */
9096  690, /* B0 = 0.021066 */
9097  30472, /* A1 = 1.859924 */
9098  -32248, /* A2 = -0.984161 */
9099  13385, /* B2 = 0.408478 */
9100  -12357, /* B1 = -0.754242 */
9101  13385, /* B0 = 0.408478 */
9102  31358, /* A1 = 1.914001 */
9103  -32366, /* A2 = -0.987732 */
9104  26488, /* B2 = 0.80835 */
9105  -25692, /* B1 = -1.568176 */
9106  26490, /* B0 = 0.808411 */
9107  7, /* Internal filter scaling */
9108  159, /* Minimum in-band energy threshold */
9109  21, /* 21/32 in-band to broad-band ratio */
9110  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9111  },
9112  { /* f360 */
9113  31397, /* A1 = -1.916321 */
9114  -32623, /* A2 = 0.995605 */
9115  -117, /* B2 = -0.003598 */
9116  0, /* B1 = 0.000000 */
9117  117, /* B0 = 0.003598 */
9118  31403, /* A1 = -1.916687 */
9119  -32700, /* A2 = 0.997925 */
9120  3388, /* B2 = 0.103401 */
9121  -3240, /* B1 = -0.197784 */
9122  3388, /* B0 = 0.103401 */
9123  31463, /* A1 = -1.920410 */
9124  -32702, /* A2 = 0.997986 */
9125  13346, /* B2 = 0.407288 */
9126  -12863, /* B1 = -0.785126 */
9127  13346, /* B0 = 0.407288 */
9128  5, /* Internal filter scaling */
9129  159, /* Minimum in-band energy threshold */
9130  21, /* 21/32 in-band to broad-band ratio */
9131  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9132  },
9133  { /* f380_420[] */
9134  30831, /* A1 = 1.881775 */
9135  -32064, /* A2 = -0.978546 */
9136  -367, /* B2 = -0.01122 */
9137  0, /* B1 = 0 */
9138  367, /* B0 = 0.01122 */
9139  30813, /* A1 = 1.880737 */
9140  -32456, /* A2 = -0.990509 */
9141  11068, /* B2 = 0.337769 */
9142  -10338, /* B1 = -0.631042 */
9143  11068, /* B0 = 0.337769 */
9144  31214, /* A1 = 1.905212 */
9145  -32491, /* A2 = -0.991577 */
9146  16374, /* B2 = 0.499695 */
9147  -15781, /* B1 = -0.963196 */
9148  16374, /* B0 = 0.499695 */
9149  7, /* Internal filter scaling */
9150  159, /* Minimum in-band energy threshold */
9151  21, /* 21/32 in-band to broad-band ratio */
9152  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9153  },
9154  { /* f392 */
9155  31152, /* A1 = -1.901428 */
9156  -32613, /* A2 = 0.995300 */
9157  -314, /* B2 = -0.009605 */
9158  0, /* B1 = 0.000000 */
9159  314, /* B0 = 0.009605 */
9160  31156, /* A1 = -1.901672 */
9161  -32694, /* A2 = 0.997742 */
9162  28847, /* B2 = 0.880371 */
9163  -2734, /* B1 = -0.166901 */
9164  28847, /* B0 = 0.880371 */
9165  31225, /* A1 = -1.905823 */
9166  -32696, /* A2 = 0.997803 */
9167  462, /* B2 = 0.014108 */
9168  -442, /* B1 = -0.027019 */
9169  462, /* B0 = 0.014108 */
9170  5, /* Internal filter scaling */
9171  159, /* Minimum in-band energy threshold */
9172  21, /* 21/32 in-band to broad-band ratio */
9173  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9174  },
9175  { /* f400_425[] */
9176  30836, /* A1 = 1.882141 */
9177  -32296, /* A2 = -0.985596 */
9178  -324, /* B2 = -0.009903 */
9179  0, /* B1 = 0 */
9180  324, /* B0 = 0.009903 */
9181  30825, /* A1 = 1.881409 */
9182  -32570, /* A2 = -0.993958 */
9183  16847, /* B2 = 0.51416 */
9184  -15792, /* B1 = -0.963898 */
9185  16847, /* B0 = 0.51416 */
9186  31106, /* A1 = 1.89856 */
9187  -32584, /* A2 = -0.994415 */
9188  9579, /* B2 = 0.292328 */
9189  -9164, /* B1 = -0.559357 */
9190  9579, /* B0 = 0.292328 */
9191  7, /* Internal filter scaling */
9192  159, /* Minimum in-band energy threshold */
9193  21, /* 21/32 in-band to broad-band ratio */
9194  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9195  },
9196  { /* f400_440[] */
9197  30702, /* A1 = 1.873962 */
9198  -32134, /* A2 = -0.980682 */
9199  -517, /* B2 = -0.015793 */
9200  0, /* B1 = 0 */
9201  517, /* B0 = 0.015793 */
9202  30676, /* A1 = 1.872375 */
9203  -32520, /* A2 = -0.992462 */
9204  8144, /* B2 = 0.24855 */
9205  -7596, /* B1 = -0.463684 */
9206  8144, /* B0 = 0.24855 */
9207  31084, /* A1 = 1.897217 */
9208  -32547, /* A2 = -0.993256 */
9209  22713, /* B2 = 0.693176 */
9210  -21734, /* B1 = -1.326599 */
9211  22713, /* B0 = 0.693176 */
9212  7, /* Internal filter scaling */
9213  159, /* Minimum in-band energy threshold */
9214  21, /* 21/32 in-band to broad-band ratio */
9215  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9216  },
9217  { /* f400_450[] */
9218  30613, /* A1 = 1.86853 */
9219  -32031, /* A2 = -0.977509 */
9220  -618, /* B2 = -0.018866 */
9221  0, /* B1 = 0 */
9222  618, /* B0 = 0.018866 */
9223  30577, /* A1 = 1.866272 */
9224  -32491, /* A2 = -0.991577 */
9225  9612, /* B2 = 0.293335 */
9226  -8935, /* B1 = -0.54541 */
9227  9612, /* B0 = 0.293335 */
9228  31071, /* A1 = 1.896484 */
9229  -32524, /* A2 = -0.992584 */
9230  21596, /* B2 = 0.659058 */
9231  -20667, /* B1 = -1.261414 */
9232  21596, /* B0 = 0.659058 */
9233  7, /* Internal filter scaling */
9234  159, /* Minimum in-band energy threshold */
9235  21, /* 21/32 in-band to broad-band ratio */
9236  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9237  },
9238  { /* f420 */
9239  30914, /* A1 = -1.886841 */
9240  -32584, /* A2 = 0.994385 */
9241  -426, /* B2 = -0.013020 */
9242  0, /* B1 = 0.000000 */
9243  426, /* B0 = 0.013020 */
9244  30914, /* A1 = -1.886841 */
9245  -32679, /* A2 = 0.997314 */
9246  17520, /* B2 = 0.534668 */
9247  -16471, /* B1 = -1.005310 */
9248  17520, /* B0 = 0.534668 */
9249  31004, /* A1 = -1.892334 */
9250  -32683, /* A2 = 0.997406 */
9251  819, /* B2 = 0.025023 */
9252  -780, /* B1 = -0.047619 */
9253  819, /* B0 = 0.025023 */
9254  5, /* Internal filter scaling */
9255  159, /* Minimum in-band energy threshold */
9256  21, /* 21/32 in-band to broad-band ratio */
9257  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9258  },
9259 #if 0
9260  { /* f425 */
9261  30881, /* A1 = -1.884827 */
9262  -32603, /* A2 = 0.994965 */
9263  -496, /* B2 = -0.015144 */
9264  0, /* B1 = 0.000000 */
9265  496, /* B0 = 0.015144 */
9266  30880, /* A1 = -1.884766 */
9267  -32692, /* A2 = 0.997711 */
9268  24767, /* B2 = 0.755859 */
9269  -23290, /* B1 = -1.421509 */
9270  24767, /* B0 = 0.755859 */
9271  30967, /* A1 = -1.890076 */
9272  -32694, /* A2 = 0.997772 */
9273  728, /* B2 = 0.022232 */
9274  -691, /* B1 = -0.042194 */
9275  728, /* B0 = 0.022232 */
9276  5, /* Internal filter scaling */
9277  159, /* Minimum in-band energy threshold */
9278  21, /* 21/32 in-band to broad-band ratio */
9279  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9280  },
9281 #else
9282  {
9283  30850,
9284  -32534,
9285  -504,
9286  0,
9287  504,
9288  30831,
9289  -32669,
9290  24303,
9291  -22080,
9292  24303,
9293  30994,
9294  -32673,
9295  1905,
9296  -1811,
9297  1905,
9298  5,
9299  129,
9300  17,
9301  0xff5
9302  },
9303 #endif
9304  { /* f425_450[] */
9305  30646, /* A1 = 1.870544 */
9306  -32327, /* A2 = -0.986572 */
9307  -287, /* B2 = -0.008769 */
9308  0, /* B1 = 0 */
9309  287, /* B0 = 0.008769 */
9310  30627, /* A1 = 1.869324 */
9311  -32607, /* A2 = -0.995087 */
9312  13269, /* B2 = 0.404968 */
9313  -12376, /* B1 = -0.755432 */
9314  13269, /* B0 = 0.404968 */
9315  30924, /* A1 = 1.887512 */
9316  -32619, /* A2 = -0.995453 */
9317  19950, /* B2 = 0.608826 */
9318  -18940, /* B1 = -1.156006 */
9319  19950, /* B0 = 0.608826 */
9320  7, /* Internal filter scaling */
9321  159, /* Minimum in-band energy threshold */
9322  21, /* 21/32 in-band to broad-band ratio */
9323  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9324  },
9325  { /* f425_475[] */
9326  30396, /* A1 = 1.855225 */
9327  -32014, /* A2 = -0.97699 */
9328  -395, /* B2 = -0.012055 */
9329  0, /* B1 = 0 */
9330  395, /* B0 = 0.012055 */
9331  30343, /* A1 = 1.85199 */
9332  -32482, /* A2 = -0.991302 */
9333  17823, /* B2 = 0.543945 */
9334  -16431, /* B1 = -1.002869 */
9335  17823, /* B0 = 0.543945 */
9336  30872, /* A1 = 1.884338 */
9337  -32516, /* A2 = -0.99231 */
9338  18124, /* B2 = 0.553101 */
9339  -17246, /* B1 = -1.052673 */
9340  18124, /* B0 = 0.553101 */
9341  7, /* Internal filter scaling */
9342  159, /* Minimum in-band energy threshold */
9343  21, /* 21/32 in-band to broad-band ratio */
9344  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9345  },
9346  { /* f435 */
9347  30796, /* A1 = -1.879639 */
9348  -32603, /* A2 = 0.994965 */
9349  -254, /* B2 = -0.007762 */
9350  0, /* B1 = 0.000000 */
9351  254, /* B0 = 0.007762 */
9352  30793, /* A1 = -1.879456 */
9353  -32692, /* A2 = 0.997711 */
9354  18934, /* B2 = 0.577820 */
9355  -17751, /* B1 = -1.083496 */
9356  18934, /* B0 = 0.577820 */
9357  30882, /* A1 = -1.884888 */
9358  -32694, /* A2 = 0.997772 */
9359  1858, /* B2 = 0.056713 */
9360  -1758, /* B1 = -0.107357 */
9361  1858, /* B0 = 0.056713 */
9362  5, /* Internal filter scaling */
9363  159, /* Minimum in-band energy threshold */
9364  21, /* 21/32 in-band to broad-band ratio */
9365  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9366  },
9367  { /* f440_450[] */
9368  30641, /* A1 = 1.870239 */
9369  -32458, /* A2 = -0.99057 */
9370  -155, /* B2 = -0.004735 */
9371  0, /* B1 = 0 */
9372  155, /* B0 = 0.004735 */
9373  30631, /* A1 = 1.869568 */
9374  -32630, /* A2 = -0.995789 */
9375  11453, /* B2 = 0.349548 */
9376  -10666, /* B1 = -0.651001 */
9377  11453, /* B0 = 0.349548 */
9378  30810, /* A1 = 1.880554 */
9379  -32634, /* A2 = -0.995941 */
9380  12237, /* B2 = 0.373474 */
9381  -11588, /* B1 = -0.707336 */
9382  12237, /* B0 = 0.373474 */
9383  7, /* Internal filter scaling */
9384  159, /* Minimum in-band energy threshold */
9385  21, /* 21/32 in-band to broad-band ratio */
9386  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9387  },
9388  { /* f440_480[] */
9389  30367, /* A1 = 1.853455 */
9390  -32147, /* A2 = -0.981079 */
9391  -495, /* B2 = -0.015113 */
9392  0, /* B1 = 0 */
9393  495, /* B0 = 0.015113 */
9394  30322, /* A1 = 1.850769 */
9395  -32543, /* A2 = -0.993134 */
9396  10031, /* B2 = 0.306152 */
9397  -9252, /* B1 = -0.564728 */
9398  10031, /* B0 = 0.306152 */
9399  30770, /* A1 = 1.878052 */
9400  -32563, /* A2 = -0.993774 */
9401  22674, /* B2 = 0.691956 */
9402  -21465, /* B1 = -1.31012 */
9403  22674, /* B0 = 0.691956 */
9404  7, /* Internal filter scaling */
9405  159, /* Minimum in-band energy threshold */
9406  21, /* 21/32 in-band to broad-band ratio */
9407  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9408  },
9409  { /* f445 */
9410  30709, /* A1 = -1.874329 */
9411  -32603, /* A2 = 0.994965 */
9412  -83, /* B2 = -0.002545 */
9413  0, /* B1 = 0.000000 */
9414  83, /* B0 = 0.002545 */
9415  30704, /* A1 = -1.874084 */
9416  -32692, /* A2 = 0.997711 */
9417  10641, /* B2 = 0.324738 */
9418  -9947, /* B1 = -0.607147 */
9419  10641, /* B0 = 0.324738 */
9420  30796, /* A1 = -1.879639 */
9421  -32694, /* A2 = 0.997772 */
9422  10079, /* B2 = 0.307587 */
9423  9513, /* B1 = 0.580688 */
9424  10079, /* B0 = 0.307587 */
9425  5, /* Internal filter scaling */
9426  159, /* Minimum in-band energy threshold */
9427  21, /* 21/32 in-band to broad-band ratio */
9428  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9429  },
9430  { /* f450 */
9431  30664, /* A1 = -1.871643 */
9432  -32603, /* A2 = 0.994965 */
9433  -164, /* B2 = -0.005029 */
9434  0, /* B1 = 0.000000 */
9435  164, /* B0 = 0.005029 */
9436  30661, /* A1 = -1.871399 */
9437  -32692, /* A2 = 0.997711 */
9438  15294, /* B2 = 0.466736 */
9439  -14275, /* B1 = -0.871307 */
9440  15294, /* B0 = 0.466736 */
9441  30751, /* A1 = -1.876953 */
9442  -32694, /* A2 = 0.997772 */
9443  3548, /* B2 = 0.108284 */
9444  -3344, /* B1 = -0.204155 */
9445  3548, /* B0 = 0.108284 */
9446  5, /* Internal filter scaling */
9447  159, /* Minimum in-band energy threshold */
9448  21, /* 21/32 in-band to broad-band ratio */
9449  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9450  },
9451  { /* f452 */
9452  30653, /* A1 = -1.870911 */
9453  -32615, /* A2 = 0.995361 */
9454  -209, /* B2 = -0.006382 */
9455  0, /* B1 = 0.000000 */
9456  209, /* B0 = 0.006382 */
9457  30647, /* A1 = -1.870605 */
9458  -32702, /* A2 = 0.997986 */
9459  18971, /* B2 = 0.578979 */
9460  -17716, /* B1 = -1.081299 */
9461  18971, /* B0 = 0.578979 */
9462  30738, /* A1 = -1.876099 */
9463  -32702, /* A2 = 0.998016 */
9464  2967, /* B2 = 0.090561 */
9465  -2793, /* B1 = -0.170502 */
9466  2967, /* B0 = 0.090561 */
9467  5, /* Internal filter scaling */
9468  159, /* Minimum in-band energy threshold */
9469  21, /* 21/32 in-band to broad-band ratio */
9470  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9471  },
9472  { /* f475 */
9473  30437, /* A1 = -1.857727 */
9474  -32603, /* A2 = 0.994965 */
9475  -264, /* B2 = -0.008062 */
9476  0, /* B1 = 0.000000 */
9477  264, /* B0 = 0.008062 */
9478  30430, /* A1 = -1.857300 */
9479  -32692, /* A2 = 0.997711 */
9480  21681, /* B2 = 0.661682 */
9481  -20082, /* B1 = -1.225708 */
9482  21681, /* B0 = 0.661682 */
9483  30526, /* A1 = -1.863220 */
9484  -32694, /* A2 = 0.997742 */
9485  1559, /* B2 = 0.047600 */
9486  -1459, /* B1 = -0.089096 */
9487  1559, /* B0 = 0.047600 */
9488  5, /* Internal filter scaling */
9489  159, /* Minimum in-band energy threshold */
9490  21, /* 21/32 in-band to broad-band ratio */
9491  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9492  },
9493  { /* f480_620[] */
9494  28975, /* A1 = 1.768494 */
9495  -30955, /* A2 = -0.944672 */
9496  -1026, /* B2 = -0.03133 */
9497  0, /* B1 = 0 */
9498  1026, /* B0 = 0.03133 */
9499  28613, /* A1 = 1.746399 */
9500  -32089, /* A2 = -0.979309 */
9501  14214, /* B2 = 0.433807 */
9502  -12202, /* B1 = -0.744812 */
9503  14214, /* B0 = 0.433807 */
9504  30243, /* A1 = 1.845947 */
9505  -32238, /* A2 = -0.983856 */
9506  24825, /* B2 = 0.757629 */
9507  -23402, /* B1 = -1.428345 */
9508  24825, /* B0 = 0.757629 */
9509  7, /* Internal filter scaling */
9510  159, /* Minimum in-band energy threshold */
9511  21, /* 21/32 in-band to broad-band ratio */
9512  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9513  },
9514  { /* f494 */
9515  30257, /* A1 = -1.846741 */
9516  -32605, /* A2 = 0.995056 */
9517  -249, /* B2 = -0.007625 */
9518  0, /* B1 = 0.000000 */
9519  249, /* B0 = 0.007625 */
9520  30247, /* A1 = -1.846191 */
9521  -32694, /* A2 = 0.997772 */
9522  18088, /* B2 = 0.552002 */
9523  -16652, /* B1 = -1.016418 */
9524  18088, /* B0 = 0.552002 */
9525  30348, /* A1 = -1.852295 */
9526  -32696, /* A2 = 0.997803 */
9527  2099, /* B2 = 0.064064 */
9528  -1953, /* B1 = -0.119202 */
9529  2099, /* B0 = 0.064064 */
9530  5, /* Internal filter scaling */
9531  159, /* Minimum in-band energy threshold */
9532  21, /* 21/32 in-band to broad-band ratio */
9533  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9534  },
9535  { /* f500 */
9536  30202, /* A1 = -1.843431 */
9537  -32624, /* A2 = 0.995622 */
9538  -413, /* B2 = -0.012622 */
9539  0, /* B1 = 0.000000 */
9540  413, /* B0 = 0.012622 */
9541  30191, /* A1 = -1.842721 */
9542  -32714, /* A2 = 0.998364 */
9543  25954, /* B2 = 0.792057 */
9544  -23890, /* B1 = -1.458131 */
9545  25954, /* B0 = 0.792057 */
9546  30296, /* A1 = -1.849172 */
9547  -32715, /* A2 = 0.998397 */
9548  2007, /* B2 = 0.061264 */
9549  -1860, /* B1 = -0.113568 */
9550  2007, /* B0 = 0.061264 */
9551  5, /* Internal filter scaling */
9552  159, /* Minimum in-band energy threshold */
9553  21, /* 21/32 in-band to broad-band ratio */
9554  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9555  },
9556  { /* f520 */
9557  30001, /* A1 = -1.831116 */
9558  -32613, /* A2 = 0.995270 */
9559  -155, /* B2 = -0.004750 */
9560  0, /* B1 = 0.000000 */
9561  155, /* B0 = 0.004750 */
9562  29985, /* A1 = -1.830200 */
9563  -32710, /* A2 = 0.998260 */
9564  6584, /* B2 = 0.200928 */
9565  -6018, /* B1 = -0.367355 */
9566  6584, /* B0 = 0.200928 */
9567  30105, /* A1 = -1.837524 */
9568  -32712, /* A2 = 0.998291 */
9569  23812, /* B2 = 0.726685 */
9570  -21936, /* B1 = -1.338928 */
9571  23812, /* B0 = 0.726685 */
9572  5, /* Internal filter scaling */
9573  159, /* Minimum in-band energy threshold */
9574  21, /* 21/32 in-band to broad-band ratio */
9575  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9576  },
9577  { /* f523 */
9578  29964, /* A1 = -1.828918 */
9579  -32601, /* A2 = 0.994904 */
9580  -101, /* B2 = -0.003110 */
9581  0, /* B1 = 0.000000 */
9582  101, /* B0 = 0.003110 */
9583  29949, /* A1 = -1.827942 */
9584  -32700, /* A2 = 0.997925 */
9585  11041, /* B2 = 0.336975 */
9586  -10075, /* B1 = -0.614960 */
9587  11041, /* B0 = 0.336975 */
9588  30070, /* A1 = -1.835388 */
9589  -32702, /* A2 = 0.997986 */
9590  16762, /* B2 = 0.511536 */
9591  -15437, /* B1 = -0.942230 */
9592  16762, /* B0 = 0.511536 */
9593  5, /* Internal filter scaling */
9594  159, /* Minimum in-band energy threshold */
9595  21, /* 21/32 in-band to broad-band ratio */
9596  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9597  },
9598  { /* f525 */
9599  29936, /* A1 = -1.827209 */
9600  -32584, /* A2 = 0.994415 */
9601  -91, /* B2 = -0.002806 */
9602  0, /* B1 = 0.000000 */
9603  91, /* B0 = 0.002806 */
9604  29921, /* A1 = -1.826233 */
9605  -32688, /* A2 = 0.997559 */
9606  11449, /* B2 = 0.349396 */
9607  -10426, /* B1 = -0.636383 */
9608  11449, /* B0 = 0.349396 */
9609  30045, /* A1 = -1.833862 */
9610  -32688, /* A2 = 0.997589 */
9611  13055, /* B2 = 0.398407 */
9612  -12028, /* B1 = -0.734161 */
9613  13055, /* B0 = 0.398407 */
9614  5, /* Internal filter scaling */
9615  159, /* Minimum in-band energy threshold */
9616  21, /* 21/32 in-band to broad-band ratio */
9617  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9618  },
9619  { /* f540_660[] */
9620  28499, /* A1 = 1.739441 */
9621  -31129, /* A2 = -0.949982 */
9622  -849, /* B2 = -0.025922 */
9623  0, /* B1 = 0 */
9624  849, /* B0 = 0.025922 */
9625  28128, /* A1 = 1.716797 */
9626  -32130, /* A2 = -0.98056 */
9627  14556, /* B2 = 0.444214 */
9628  -12251, /* B1 = -0.747772 */
9629  14556, /* B0 = 0.444244 */
9630  29667, /* A1 = 1.81073 */
9631  -32244, /* A2 = -0.984039 */
9632  23038, /* B2 = 0.703064 */
9633  -21358, /* B1 = -1.303589 */
9634  23040, /* B0 = 0.703125 */
9635  7, /* Internal filter scaling */
9636  159, /* Minimum in-band energy threshold */
9637  21, /* 21/32 in-band to broad-band ratio */
9638  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9639  },
9640  { /* f587 */
9641  29271, /* A1 = -1.786560 */
9642  -32599, /* A2 = 0.994873 */
9643  -490, /* B2 = -0.014957 */
9644  0, /* B1 = 0.000000 */
9645  490, /* B0 = 0.014957 */
9646  29246, /* A1 = -1.785095 */
9647  -32700, /* A2 = 0.997925 */
9648  28961, /* B2 = 0.883850 */
9649  -25796, /* B1 = -1.574463 */
9650  28961, /* B0 = 0.883850 */
9651  29383, /* A1 = -1.793396 */
9652  -32700, /* A2 = 0.997955 */
9653  1299, /* B2 = 0.039650 */
9654  -1169, /* B1 = -0.071396 */
9655  1299, /* B0 = 0.039650 */
9656  5, /* Internal filter scaling */
9657  159, /* Minimum in-band energy threshold */
9658  21, /* 21/32 in-band to broad-band ratio */
9659  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9660  },
9661  { /* f590 */
9662  29230, /* A1 = -1.784058 */
9663  -32584, /* A2 = 0.994415 */
9664  -418, /* B2 = -0.012757 */
9665  0, /* B1 = 0.000000 */
9666  418, /* B0 = 0.012757 */
9667  29206, /* A1 = -1.782593 */
9668  -32688, /* A2 = 0.997559 */
9669  36556, /* B2 = 1.115601 */
9670  -32478, /* B1 = -1.982300 */
9671  36556, /* B0 = 1.115601 */
9672  29345, /* A1 = -1.791077 */
9673  -32688, /* A2 = 0.997589 */
9674  897, /* B2 = 0.027397 */
9675  -808, /* B1 = -0.049334 */
9676  897, /* B0 = 0.027397 */
9677  5, /* Internal filter scaling */
9678  159, /* Minimum in-band energy threshold */
9679  21, /* 21/32 in-band to broad-band ratio */
9680  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9681  },
9682  { /* f600 */
9683  29116, /* A1 = -1.777100 */
9684  -32603, /* A2 = 0.994965 */
9685  -165, /* B2 = -0.005039 */
9686  0, /* B1 = 0.000000 */
9687  165, /* B0 = 0.005039 */
9688  29089, /* A1 = -1.775452 */
9689  -32708, /* A2 = 0.998199 */
9690  6963, /* B2 = 0.212494 */
9691  -6172, /* B1 = -0.376770 */
9692  6963, /* B0 = 0.212494 */
9693  29237, /* A1 = -1.784485 */
9694  -32710, /* A2 = 0.998230 */
9695  24197, /* B2 = 0.738464 */
9696  -21657, /* B1 = -1.321899 */
9697  24197, /* B0 = 0.738464 */
9698  5, /* Internal filter scaling */
9699  159, /* Minimum in-band energy threshold */
9700  21, /* 21/32 in-band to broad-band ratio */
9701  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9702  },
9703  { /* f660 */
9704  28376, /* A1 = -1.731934 */
9705  -32567, /* A2 = 0.993896 */
9706  -363, /* B2 = -0.011102 */
9707  0, /* B1 = 0.000000 */
9708  363, /* B0 = 0.011102 */
9709  28337, /* A1 = -1.729614 */
9710  -32683, /* A2 = 0.997434 */
9711  21766, /* B2 = 0.664246 */
9712  -18761, /* B1 = -1.145081 */
9713  21766, /* B0 = 0.664246 */
9714  28513, /* A1 = -1.740356 */
9715  -32686, /* A2 = 0.997498 */
9716  2509, /* B2 = 0.076584 */
9717  -2196, /* B1 = -0.134041 */
9718  2509, /* B0 = 0.076584 */
9719  5, /* Internal filter scaling */
9720  159, /* Minimum in-band energy threshold */
9721  21, /* 21/32 in-band to broad-band ratio */
9722  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9723  },
9724  { /* f700 */
9725  27844, /* A1 = -1.699463 */
9726  -32563, /* A2 = 0.993744 */
9727  -366, /* B2 = -0.011187 */
9728  0, /* B1 = 0.000000 */
9729  366, /* B0 = 0.011187 */
9730  27797, /* A1 = -1.696655 */
9731  -32686, /* A2 = 0.997498 */
9732  22748, /* B2 = 0.694214 */
9733  -19235, /* B1 = -1.174072 */
9734  22748, /* B0 = 0.694214 */
9735  27995, /* A1 = -1.708740 */
9736  -32688, /* A2 = 0.997559 */
9737  2964, /* B2 = 0.090477 */
9738  -2546, /* B1 = -0.155449 */
9739  2964, /* B0 = 0.090477 */
9740  5, /* Internal filter scaling */
9741  159, /* Minimum in-band energy threshold */
9742  21, /* 21/32 in-band to broad-band ratio */
9743  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9744  },
9745  { /* f740 */
9746  27297, /* A1 = -1.666077 */
9747  -32551, /* A2 = 0.993408 */
9748  -345, /* B2 = -0.010540 */
9749  0, /* B1 = 0.000000 */
9750  345, /* B0 = 0.010540 */
9751  27240, /* A1 = -1.662598 */
9752  -32683, /* A2 = 0.997406 */
9753  22560, /* B2 = 0.688477 */
9754  -18688, /* B1 = -1.140625 */
9755  22560, /* B0 = 0.688477 */
9756  27461, /* A1 = -1.676147 */
9757  -32684, /* A2 = 0.997467 */
9758  3541, /* B2 = 0.108086 */
9759  -2985, /* B1 = -0.182220 */
9760  3541, /* B0 = 0.108086 */
9761  5, /* Internal filter scaling */
9762  159, /* Minimum in-band energy threshold */
9763  21, /* 21/32 in-band to broad-band ratio */
9764  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9765  },
9766  { /* f750 */
9767  27155, /* A1 = -1.657410 */
9768  -32551, /* A2 = 0.993408 */
9769  -462, /* B2 = -0.014117 */
9770  0, /* B1 = 0.000000 */
9771  462, /* B0 = 0.014117 */
9772  27097, /* A1 = -1.653870 */
9773  -32683, /* A2 = 0.997406 */
9774  32495, /* B2 = 0.991699 */
9775  -26776, /* B1 = -1.634338 */
9776  32495, /* B0 = 0.991699 */
9777  27321, /* A1 = -1.667542 */
9778  -32684, /* A2 = 0.997467 */
9779  1835, /* B2 = 0.056007 */
9780  -1539, /* B1 = -0.093948 */
9781  1835, /* B0 = 0.056007 */
9782  5, /* Internal filter scaling */
9783  159, /* Minimum in-band energy threshold */
9784  21, /* 21/32 in-band to broad-band ratio */
9785  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9786  },
9787  { /* f750_1450[] */
9788  19298, /* A1 = 1.177917 */
9789  -24471, /* A2 = -0.746796 */
9790  -4152, /* B2 = -0.126709 */
9791  0, /* B1 = 0 */
9792  4152, /* B0 = 0.126709 */
9793  12902, /* A1 = 0.787476 */
9794  -29091, /* A2 = -0.887817 */
9795  12491, /* B2 = 0.38121 */
9796  -1794, /* B1 = -0.109528 */
9797  12494, /* B0 = 0.381317 */
9798  26291, /* A1 = 1.604736 */
9799  -30470, /* A2 = -0.929901 */
9800  28859, /* B2 = 0.880737 */
9801  -26084, /* B1 = -1.592102 */
9802  28861, /* B0 = 0.880798 */
9803  7, /* Internal filter scaling */
9804  159, /* Minimum in-band energy threshold */
9805  21, /* 21/32 in-band to broad-band ratio */
9806  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9807  },
9808  { /* f770 */
9809  26867, /* A1 = -1.639832 */
9810  -32551, /* A2 = 0.993408 */
9811  -123, /* B2 = -0.003755 */
9812  0, /* B1 = 0.000000 */
9813  123, /* B0 = 0.003755 */
9814  26805, /* A1 = -1.636108 */
9815  -32683, /* A2 = 0.997406 */
9816  17297, /* B2 = 0.527863 */
9817  -14096, /* B1 = -0.860382 */
9818  17297, /* B0 = 0.527863 */
9819  27034, /* A1 = -1.650085 */
9820  -32684, /* A2 = 0.997467 */
9821  12958, /* B2 = 0.395477 */
9822  -10756, /* B1 = -0.656525 */
9823  12958, /* B0 = 0.395477 */
9824  5, /* Internal filter scaling */
9825  159, /* Minimum in-band energy threshold */
9826  21, /* 21/32 in-band to broad-band ratio */
9827  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9828  },
9829  { /* f800 */
9830  26413, /* A1 = -1.612122 */
9831  -32547, /* A2 = 0.993286 */
9832  -223, /* B2 = -0.006825 */
9833  0, /* B1 = 0.000000 */
9834  223, /* B0 = 0.006825 */
9835  26342, /* A1 = -1.607849 */
9836  -32686, /* A2 = 0.997498 */
9837  6391, /* B2 = 0.195053 */
9838  -5120, /* B1 = -0.312531 */
9839  6391, /* B0 = 0.195053 */
9840  26593, /* A1 = -1.623108 */
9841  -32688, /* A2 = 0.997559 */
9842  23681, /* B2 = 0.722717 */
9843  -19328, /* B1 = -1.179688 */
9844  23681, /* B0 = 0.722717 */
9845  5, /* Internal filter scaling */
9846  159, /* Minimum in-band energy threshold */
9847  21, /* 21/32 in-band to broad-band ratio */
9848  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9849  },
9850  { /* f816 */
9851  26168, /* A1 = -1.597209 */
9852  -32528, /* A2 = 0.992706 */
9853  -235, /* B2 = -0.007182 */
9854  0, /* B1 = 0.000000 */
9855  235, /* B0 = 0.007182 */
9856  26092, /* A1 = -1.592590 */
9857  -32675, /* A2 = 0.997192 */
9858  20823, /* B2 = 0.635498 */
9859  -16510, /* B1 = -1.007751 */
9860  20823, /* B0 = 0.635498 */
9861  26363, /* A1 = -1.609070 */
9862  -32677, /* A2 = 0.997253 */
9863  6739, /* B2 = 0.205688 */
9864  -5459, /* B1 = -0.333206 */
9865  6739, /* B0 = 0.205688 */
9866  5, /* Internal filter scaling */
9867  159, /* Minimum in-band energy threshold */
9868  21, /* 21/32 in-band to broad-band ratio */
9869  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9870  },
9871  { /* f850 */
9872  25641, /* A1 = -1.565063 */
9873  -32536, /* A2 = 0.992950 */
9874  -121, /* B2 = -0.003707 */
9875  0, /* B1 = 0.000000 */
9876  121, /* B0 = 0.003707 */
9877  25560, /* A1 = -1.560059 */
9878  -32684, /* A2 = 0.997437 */
9879  18341, /* B2 = 0.559753 */
9880  -14252, /* B1 = -0.869904 */
9881  18341, /* B0 = 0.559753 */
9882  25837, /* A1 = -1.577026 */
9883  -32684, /* A2 = 0.997467 */
9884  16679, /* B2 = 0.509003 */
9885  -13232, /* B1 = -0.807648 */
9886  16679, /* B0 = 0.509003 */
9887  5, /* Internal filter scaling */
9888  159, /* Minimum in-band energy threshold */
9889  21, /* 21/32 in-band to broad-band ratio */
9890  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9891  },
9892  { /* f857_1645[] */
9893  16415, /* A1 = 1.001953 */
9894  -23669, /* A2 = -0.722321 */
9895  -4549, /* B2 = -0.138847 */
9896  0, /* B1 = 0 */
9897  4549, /* B0 = 0.138847 */
9898  8456, /* A1 = 0.516174 */
9899  -28996, /* A2 = -0.884918 */
9900  13753, /* B2 = 0.419724 */
9901  -12, /* B1 = -0.000763 */
9902  13757, /* B0 = 0.419846 */
9903  24632, /* A1 = 1.503418 */
9904  -30271, /* A2 = -0.923828 */
9905  29070, /* B2 = 0.887146 */
9906  -25265, /* B1 = -1.542114 */
9907  29073, /* B0 = 0.887268 */
9908  7, /* Internal filter scaling */
9909  159, /* Minimum in-band energy threshold */
9910  21, /* 21/32 in-band to broad-band ratio */
9911  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9912  },
9913  { /* f900 */
9914  24806, /* A1 = -1.514099 */
9915  -32501, /* A2 = 0.991852 */
9916  -326, /* B2 = -0.009969 */
9917  0, /* B1 = 0.000000 */
9918  326, /* B0 = 0.009969 */
9919  24709, /* A1 = -1.508118 */
9920  -32659, /* A2 = 0.996674 */
9921  20277, /* B2 = 0.618835 */
9922  -15182, /* B1 = -0.926636 */
9923  20277, /* B0 = 0.618835 */
9924  25022, /* A1 = -1.527222 */
9925  -32661, /* A2 = 0.996735 */
9926  4320, /* B2 = 0.131836 */
9927  -3331, /* B1 = -0.203339 */
9928  4320, /* B0 = 0.131836 */
9929  5, /* Internal filter scaling */
9930  159, /* Minimum in-band energy threshold */
9931  21, /* 21/32 in-band to broad-band ratio */
9932  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9933  },
9934  { /* f900_1300[] */
9935  19776, /* A1 = 1.207092 */
9936  -27437, /* A2 = -0.837341 */
9937  -2666, /* B2 = -0.081371 */
9938  0, /* B1 = 0 */
9939  2666, /* B0 = 0.081371 */
9940  16302, /* A1 = 0.995026 */
9941  -30354, /* A2 = -0.926361 */
9942  10389, /* B2 = 0.317062 */
9943  -3327, /* B1 = -0.203064 */
9944  10389, /* B0 = 0.317062 */
9945  24299, /* A1 = 1.483154 */
9946  -30930, /* A2 = -0.943909 */
9947  25016, /* B2 = 0.763428 */
9948  -21171, /* B1 = -1.292236 */
9949  25016, /* B0 = 0.763428 */
9950  7, /* Internal filter scaling */
9951  159, /* Minimum in-band energy threshold */
9952  21, /* 21/32 in-band to broad-band ratio */
9953  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9954  },
9955  { /* f935_1215[] */
9956  20554, /* A1 = 1.254517 */
9957  -28764, /* A2 = -0.877838 */
9958  -2048, /* B2 = -0.062515 */
9959  0, /* B1 = 0 */
9960  2048, /* B0 = 0.062515 */
9961  18209, /* A1 = 1.11145 */
9962  -30951, /* A2 = -0.94458 */
9963  9390, /* B2 = 0.286575 */
9964  -3955, /* B1 = -0.241455 */
9965  9390, /* B0 = 0.286575 */
9966  23902, /* A1 = 1.458923 */
9967  -31286, /* A2 = -0.954803 */
9968  23252, /* B2 = 0.709595 */
9969  -19132, /* B1 = -1.167725 */
9970  23252, /* B0 = 0.709595 */
9971  7, /* Internal filter scaling */
9972  159, /* Minimum in-band energy threshold */
9973  21, /* 21/32 in-band to broad-band ratio */
9974  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9975  },
9976  { /* f941_1477[] */
9977  17543, /* A1 = 1.07074 */
9978  -26220, /* A2 = -0.800201 */
9979  -3298, /* B2 = -0.100647 */
9980  0, /* B1 = 0 */
9981  3298, /* B0 = 0.100647 */
9982  12423, /* A1 = 0.75827 */
9983  -30036, /* A2 = -0.916626 */
9984  12651, /* B2 = 0.386078 */
9985  -2444, /* B1 = -0.14917 */
9986  12653, /* B0 = 0.386154 */
9987  23518, /* A1 = 1.435425 */
9988  -30745, /* A2 = -0.938293 */
9989  27282, /* B2 = 0.832581 */
9990  -22529, /* B1 = -1.375122 */
9991  27286, /* B0 = 0.832703 */
9992  7, /* Internal filter scaling */
9993  159, /* Minimum in-band energy threshold */
9994  21, /* 21/32 in-band to broad-band ratio */
9995  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9996  },
9997  { /* f942 */
9998  24104, /* A1 = -1.471252 */
9999  -32507, /* A2 = 0.992065 */
10000  -351, /* B2 = -0.010722 */
10001  0, /* B1 = 0.000000 */
10002  351, /* B0 = 0.010722 */
10003  23996, /* A1 = -1.464600 */
10004  -32671, /* A2 = 0.997040 */
10005  22848, /* B2 = 0.697266 */
10006  -16639, /* B1 = -1.015564 */
10007  22848, /* B0 = 0.697266 */
10008  24332, /* A1 = -1.485168 */
10009  -32673, /* A2 = 0.997101 */
10010  4906, /* B2 = 0.149727 */
10011  -3672, /* B1 = -0.224174 */
10012  4906, /* B0 = 0.149727 */
10013  5, /* Internal filter scaling */
10014  159, /* Minimum in-band energy threshold */
10015  21, /* 21/32 in-band to broad-band ratio */
10016  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10017  },
10018  { /* f950 */
10019  23967, /* A1 = -1.462830 */
10020  -32507, /* A2 = 0.992065 */
10021  -518, /* B2 = -0.015821 */
10022  0, /* B1 = 0.000000 */
10023  518, /* B0 = 0.015821 */
10024  23856, /* A1 = -1.456055 */
10025  -32671, /* A2 = 0.997040 */
10026  26287, /* B2 = 0.802246 */
10027  -19031, /* B1 = -1.161560 */
10028  26287, /* B0 = 0.802246 */
10029  24195, /* A1 = -1.476746 */
10030  -32673, /* A2 = 0.997101 */
10031  2890, /* B2 = 0.088196 */
10032  -2151, /* B1 = -0.131317 */
10033  2890, /* B0 = 0.088196 */
10034  5, /* Internal filter scaling */
10035  159, /* Minimum in-band energy threshold */
10036  21, /* 21/32 in-band to broad-band ratio */
10037  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10038  },
10039  { /* f950_1400[] */
10040  18294, /* A1 = 1.116638 */
10041  -26962, /* A2 = -0.822845 */
10042  -2914, /* B2 = -0.088936 */
10043  0, /* B1 = 0 */
10044  2914, /* B0 = 0.088936 */
10045  14119, /* A1 = 0.861786 */
10046  -30227, /* A2 = -0.922455 */
10047  11466, /* B2 = 0.349945 */
10048  -2833, /* B1 = -0.172943 */
10049  11466, /* B0 = 0.349945 */
10050  23431, /* A1 = 1.430115 */
10051  -30828, /* A2 = -0.940796 */
10052  25331, /* B2 = 0.773071 */
10053  -20911, /* B1 = -1.276367 */
10054  25331, /* B0 = 0.773071 */
10055  7, /* Internal filter scaling */
10056  159, /* Minimum in-band energy threshold */
10057  21, /* 21/32 in-band to broad-band ratio */
10058  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10059  },
10060  { /* f975 */
10061  23521, /* A1 = -1.435608 */
10062  -32489, /* A2 = 0.991516 */
10063  -193, /* B2 = -0.005915 */
10064  0, /* B1 = 0.000000 */
10065  193, /* B0 = 0.005915 */
10066  23404, /* A1 = -1.428467 */
10067  -32655, /* A2 = 0.996582 */
10068  17740, /* B2 = 0.541412 */
10069  -12567, /* B1 = -0.767029 */
10070  17740, /* B0 = 0.541412 */
10071  23753, /* A1 = -1.449829 */
10072  -32657, /* A2 = 0.996613 */
10073  9090, /* B2 = 0.277405 */
10074  -6662, /* B1 = -0.406647 */
10075  9090, /* B0 = 0.277405 */
10076  5, /* Internal filter scaling */
10077  159, /* Minimum in-band energy threshold */
10078  21, /* 21/32 in-band to broad-band ratio */
10079  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10080  },
10081  { /* f1000 */
10082  23071, /* A1 = -1.408203 */
10083  -32489, /* A2 = 0.991516 */
10084  -293, /* B2 = -0.008965 */
10085  0, /* B1 = 0.000000 */
10086  293, /* B0 = 0.008965 */
10087  22951, /* A1 = -1.400818 */
10088  -32655, /* A2 = 0.996582 */
10089  5689, /* B2 = 0.173645 */
10090  -3951, /* B1 = -0.241150 */
10091  5689, /* B0 = 0.173645 */
10092  23307, /* A1 = -1.422607 */
10093  -32657, /* A2 = 0.996613 */
10094  18692, /* B2 = 0.570435 */
10095  -13447, /* B1 = -0.820770 */
10096  18692, /* B0 = 0.570435 */
10097  5, /* Internal filter scaling */
10098  159, /* Minimum in-band energy threshold */
10099  21, /* 21/32 in-band to broad-band ratio */
10100  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10101  },
10102  { /* f1020 */
10103  22701, /* A1 = -1.385620 */
10104  -32474, /* A2 = 0.991058 */
10105  -292, /* B2 = -0.008933 */
10106  0, /*163840 , B1 = 10.000000 */
10107  292, /* B0 = 0.008933 */
10108  22564, /* A1 = -1.377258 */
10109  -32655, /* A2 = 0.996552 */
10110  20756, /* B2 = 0.633423 */
10111  -14176, /* B1 = -0.865295 */
10112  20756, /* B0 = 0.633423 */
10113  22960, /* A1 = -1.401428 */
10114  -32657, /* A2 = 0.996613 */
10115  6520, /* B2 = 0.198990 */
10116  -4619, /* B1 = -0.281937 */
10117  6520, /* B0 = 0.198990 */
10118  5, /* Internal filter scaling */
10119  159, /* Minimum in-band energy threshold */
10120  21, /* 21/32 in-band to broad-band ratio */
10121  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10122  },
10123  { /* f1050 */
10124  22142, /* A1 = -1.351501 */
10125  -32474, /* A2 = 0.991058 */
10126  -147, /* B2 = -0.004493 */
10127  0, /* B1 = 0.000000 */
10128  147, /* B0 = 0.004493 */
10129  22000, /* A1 = -1.342834 */
10130  -32655, /* A2 = 0.996552 */
10131  15379, /* B2 = 0.469360 */
10132  -10237, /* B1 = -0.624847 */
10133  15379, /* B0 = 0.469360 */
10134  22406, /* A1 = -1.367554 */
10135  -32657, /* A2 = 0.996613 */
10136  17491, /* B2 = 0.533783 */
10137  -12096, /* B1 = -0.738312 */
10138  17491, /* B0 = 0.533783 */
10139  5, /* Internal filter scaling */
10140  159, /* Minimum in-band energy threshold */
10141  21, /* 21/32 in-band to broad-band ratio */
10142  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10143  },
10144  { /* f1100_1750[] */
10145  12973, /* A1 = 0.79184 */
10146  -24916, /* A2 = -0.760376 */
10147  6655, /* B2 = 0.203102 */
10148  367, /* B1 = 0.0224 */
10149  6657, /* B0 = 0.203171 */
10150  5915, /* A1 = 0.361053 */
10151  -29560, /* A2 = -0.90213 */
10152  -7777, /* B2 = -0.23735 */
10153  0, /* B1 = 0 */
10154  7777, /* B0 = 0.23735 */
10155  20510, /* A1 = 1.251892 */
10156  -30260, /* A2 = -0.923462 */
10157  26662, /* B2 = 0.81366 */
10158  -20573, /* B1 = -1.255737 */
10159  26668, /* B0 = 0.813843 */
10160  7, /* Internal filter scaling */
10161  159, /* Minimum in-band energy threshold */
10162  21, /* 21/32 in-band to broad-band ratio */
10163  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10164  },
10165  { /* f1140 */
10166  20392, /* A1 = -1.244629 */
10167  -32460, /* A2 = 0.990601 */
10168  -270, /* B2 = -0.008240 */
10169  0, /* B1 = 0.000000 */
10170  270, /* B0 = 0.008240 */
10171  20218, /* A1 = -1.234009 */
10172  -32655, /* A2 = 0.996582 */
10173  21337, /* B2 = 0.651154 */
10174  -13044, /* B1 = -0.796143 */
10175  21337, /* B0 = 0.651154 */
10176  20684, /* A1 = -1.262512 */
10177  -32657, /* A2 = 0.996643 */
10178  8572, /* B2 = 0.261612 */
10179  -5476, /* B1 = -0.334244 */
10180  8572, /* B0 = 0.261612 */
10181  5, /* Internal filter scaling */
10182  159, /* Minimum in-band energy threshold */
10183  21, /* 21/32 in-band to broad-band ratio */
10184  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10185  },
10186  { /* f1200 */
10187  19159, /* A1 = -1.169373 */
10188  -32456, /* A2 = 0.990509 */
10189  -335, /* B2 = -0.010252 */
10190  0, /* B1 = 0.000000 */
10191  335, /* B0 = 0.010252 */
10192  18966, /* A1 = -1.157593 */
10193  -32661, /* A2 = 0.996735 */
10194  6802, /* B2 = 0.207588 */
10195  -3900, /* B1 = -0.238098 */
10196  6802, /* B0 = 0.207588 */
10197  19467, /* A1 = -1.188232 */
10198  -32661, /* A2 = 0.996765 */
10199  25035, /* B2 = 0.764008 */
10200  -15049, /* B1 = -0.918579 */
10201  25035, /* B0 = 0.764008 */
10202  5, /* Internal filter scaling */
10203  159, /* Minimum in-band energy threshold */
10204  21, /* 21/32 in-band to broad-band ratio */
10205  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10206  },
10207  { /* f1209 */
10208  18976, /* A1 = -1.158264 */
10209  -32439, /* A2 = 0.989990 */
10210  -183, /* B2 = -0.005588 */
10211  0, /* B1 = 0.000000 */
10212  183, /* B0 = 0.005588 */
10213  18774, /* A1 = -1.145874 */
10214  -32650, /* A2 = 0.996429 */
10215  15468, /* B2 = 0.472076 */
10216  -8768, /* B1 = -0.535217 */
10217  15468, /* B0 = 0.472076 */
10218  19300, /* A1 = -1.177979 */
10219  -32652, /* A2 = 0.996490 */
10220  19840, /* B2 = 0.605499 */
10221  -11842, /* B1 = -0.722809 */
10222  19840, /* B0 = 0.605499 */
10223  5, /* Internal filter scaling */
10224  159, /* Minimum in-band energy threshold */
10225  21, /* 21/32 in-band to broad-band ratio */
10226  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10227  },
10228  { /* f1330 */
10229  16357, /* A1 = -0.998413 */
10230  -32368, /* A2 = 0.987793 */
10231  -217, /* B2 = -0.006652 */
10232  0, /* B1 = 0.000000 */
10233  217, /* B0 = 0.006652 */
10234  16107, /* A1 = -0.983126 */
10235  -32601, /* A2 = 0.994904 */
10236  11602, /* B2 = 0.354065 */
10237  -5555, /* B1 = -0.339111 */
10238  11602, /* B0 = 0.354065 */
10239  16722, /* A1 = -1.020630 */
10240  -32603, /* A2 = 0.994965 */
10241  15574, /* B2 = 0.475311 */
10242  -8176, /* B1 = -0.499069 */
10243  15574, /* B0 = 0.475311 */
10244  5, /* Internal filter scaling */
10245  159, /* Minimum in-band energy threshold */
10246  21, /* 21/32 in-band to broad-band ratio */
10247  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10248  },
10249  { /* f1336 */
10250  16234, /* A1 = -0.990875 */
10251  32404, /* A2 = -0.988922 */
10252  -193, /* B2 = -0.005908 */
10253  0, /* B1 = 0.000000 */
10254  193, /* B0 = 0.005908 */
10255  15986, /* A1 = -0.975769 */
10256  -32632, /* A2 = 0.995880 */
10257  18051, /* B2 = 0.550903 */
10258  -8658, /* B1 = -0.528473 */
10259  18051, /* B0 = 0.550903 */
10260  16591, /* A1 = -1.012695 */
10261  -32634, /* A2 = 0.995941 */
10262  15736, /* B2 = 0.480240 */
10263  -8125, /* B1 = -0.495926 */
10264  15736, /* B0 = 0.480240 */
10265  5, /* Internal filter scaling */
10266  159, /* Minimum in-band energy threshold */
10267  21, /* 21/32 in-band to broad-band ratio */
10268  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10269  },
10270  { /* f1366 */
10271  15564, /* A1 = -0.949982 */
10272  -32404, /* A2 = 0.988922 */
10273  -269, /* B2 = -0.008216 */
10274  0, /* B1 = 0.000000 */
10275  269, /* B0 = 0.008216 */
10276  15310, /* A1 = -0.934479 */
10277  -32632, /* A2 = 0.995880 */
10278  10815, /* B2 = 0.330063 */
10279  -4962, /* B1 = -0.302887 */
10280  10815, /* B0 = 0.330063 */
10281  15924, /* A1 = -0.971924 */
10282  -32634, /* A2 = 0.995941 */
10283  18880, /* B2 = 0.576172 */
10284  -9364, /* B1 = -0.571594 */
10285  18880, /* B0 = 0.576172 */
10286  5, /* Internal filter scaling */
10287  159, /* Minimum in-band energy threshold */
10288  21, /* 21/32 in-band to broad-band ratio */
10289  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10290  },
10291  { /* f1380 */
10292  15247, /* A1 = -0.930603 */
10293  -32397, /* A2 = 0.988708 */
10294  -244, /* B2 = -0.007451 */
10295  0, /* B1 = 0.000000 */
10296  244, /* B0 = 0.007451 */
10297  14989, /* A1 = -0.914886 */
10298  -32627, /* A2 = 0.995697 */
10299  18961, /* B2 = 0.578644 */
10300  -8498, /* B1 = -0.518707 */
10301  18961, /* B0 = 0.578644 */
10302  15608, /* A1 = -0.952667 */
10303  -32628, /* A2 = 0.995758 */
10304  11145, /* B2 = 0.340134 */
10305  -5430, /* B1 = -0.331467 */
10306  11145, /* B0 = 0.340134 */
10307  5, /* Internal filter scaling */
10308  159, /* Minimum in-band energy threshold */
10309  21, /* 21/32 in-band to broad-band ratio */
10310  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10311  },
10312  { /* f1400 */
10313  14780, /* A1 = -0.902130 */
10314  -32393, /* A2 = 0.988586 */
10315  -396, /* B2 = -0.012086 */
10316  0, /* B1 = 0.000000 */
10317  396, /* B0 = 0.012086 */
10318  14510, /* A1 = -0.885651 */
10319  -32630, /* A2 = 0.995819 */
10320  6326, /* B2 = 0.193069 */
10321  -2747, /* B1 = -0.167671 */
10322  6326, /* B0 = 0.193069 */
10323  15154, /* A1 = -0.924957 */
10324  -32632, /* A2 = 0.995850 */
10325  23235, /* B2 = 0.709076 */
10326  -10983, /* B1 = -0.670380 */
10327  23235, /* B0 = 0.709076 */
10328  5, /* Internal filter scaling */
10329  159, /* Minimum in-band energy threshold */
10330  21, /* 21/32 in-band to broad-band ratio */
10331  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10332  },
10333  { /* f1477 */
10334  13005, /* A1 = -0.793793 */
10335  -32368, /* A2 = 0.987823 */
10336  -500, /* B2 = -0.015265 */
10337  0, /* B1 = 0.000000 */
10338  500, /* B0 = 0.015265 */
10339  12708, /* A1 = -0.775665 */
10340  -32615, /* A2 = 0.995331 */
10341  11420, /* B2 = 0.348526 */
10342  -4306, /* B1 = -0.262833 */
10343  11420, /* B0 = 0.348526 */
10344  13397, /* A1 = -0.817688 */
10345  -32615, /* A2 = 0.995361 */
10346  9454, /* B2 = 0.288528 */
10347  -3981, /* B1 = -0.243027 */
10348  9454, /* B0 = 0.288528 */
10349  5, /* Internal filter scaling */
10350  159, /* Minimum in-band energy threshold */
10351  21, /* 21/32 in-band to broad-band ratio */
10352  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10353  },
10354  { /* f1600 */
10355  10046, /* A1 = -0.613190 */
10356  -32331, /* A2 = 0.986694 */
10357  -455, /* B2 = -0.013915 */
10358  0, /* B1 = 0.000000 */
10359  455, /* B0 = 0.013915 */
10360  9694, /* A1 = -0.591705 */
10361  -32601, /* A2 = 0.994934 */
10362  6023, /* B2 = 0.183815 */
10363  -1708, /* B1 = -0.104279 */
10364  6023, /* B0 = 0.183815 */
10365  10478, /* A1 = -0.639587 */
10366  -32603, /* A2 = 0.994965 */
10367  22031, /* B2 = 0.672333 */
10368  -7342, /* B1 = -0.448151 */
10369  22031, /* B0 = 0.672333 */
10370  5, /* Internal filter scaling */
10371  159, /* Minimum in-band energy threshold */
10372  21, /* 21/32 in-band to broad-band ratio */
10373  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10374  },
10375  { /* f1633_1638[] */
10376  9181, /* A1 = 0.560394 */
10377  -32256, /* A2 = -0.984375 */
10378  -556, /* B2 = -0.016975 */
10379  0, /* B1 = 0 */
10380  556, /* B0 = 0.016975 */
10381  8757, /* A1 = 0.534515 */
10382  -32574, /* A2 = -0.99408 */
10383  8443, /* B2 = 0.25769 */
10384  -2135, /* B1 = -0.130341 */
10385  8443, /* B0 = 0.25769 */
10386  9691, /* A1 = 0.591522 */
10387  -32574, /* A2 = -0.99411 */
10388  15446, /* B2 = 0.471375 */
10389  -4809, /* B1 = -0.293579 */
10390  15446, /* B0 = 0.471375 */
10391  7, /* Internal filter scaling */
10392  159, /* Minimum in-band energy threshold */
10393  21, /* 21/32 in-band to broad-band ratio */
10394  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10395  },
10396  { /* f1800 */
10397  5076, /* A1 = -0.309875 */
10398  -32304, /* A2 = 0.985840 */
10399  -508, /* B2 = -0.015503 */
10400  0, /* B1 = 0.000000 */
10401  508, /* B0 = 0.015503 */
10402  4646, /* A1 = -0.283600 */
10403  -32605, /* A2 = 0.995026 */
10404  6742, /* B2 = 0.205780 */
10405  -878, /* B1 = -0.053635 */
10406  6742, /* B0 = 0.205780 */
10407  5552, /* A1 = -0.338928 */
10408  -32605, /* A2 = 0.995056 */
10409  23667, /* B2 = 0.722260 */
10410  -4297, /* B1 = -0.262329 */
10411  23667, /* B0 = 0.722260 */
10412  5, /* Internal filter scaling */
10413  159, /* Minimum in-band energy threshold */
10414  21, /* 21/32 in-band to broad-band ratio */
10415  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10416  },
10417  { /* f1860 */
10418  3569, /* A1 = -0.217865 */
10419  -32292, /* A2 = 0.985504 */
10420  -239, /* B2 = -0.007322 */
10421  0, /* B1 = 0.000000 */
10422  239, /* B0 = 0.007322 */
10423  3117, /* A1 = -0.190277 */
10424  -32603, /* A2 = 0.994965 */
10425  18658, /* B2 = 0.569427 */
10426  -1557, /* B1 = -0.095032 */
10427  18658, /* B0 = 0.569427 */
10428  4054, /* A1 = -0.247437 */
10429  -32603, /* A2 = 0.994965 */
10430  18886, /* B2 = 0.576385 */
10431  -2566, /* B1 = -0.156647 */
10432  18886, /* B0 = 0.576385 */
10433  5, /* Internal filter scaling */
10434  159, /* Minimum in-band energy threshold */
10435  21, /* 21/32 in-band to broad-band ratio */
10436  0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10437  },
10438 };
10439 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10440 {
10441  unsigned short cmd;
10442  int cnt, max;
10443 
10444  if (jf->filter > 3) {
10445  return -1;
10446  }
10447  if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10448 
10449  return -1;
10450  if (!jf->enable) {
10451  if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10452 
10453  return -1;
10454  else
10455  return 0;
10456  } else {
10457  if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10458 
10459  return -1;
10460  /* Select the filter (f0 - f3) to use. */
10461  if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10462  return -1;
10463  }
10464  if (jf->freq < 12 && jf->freq > 3) {
10465  /* Select the frequency for the selected filter. */
10466  if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10467  return -1;
10468  } else if (jf->freq > 11) {
10469  /* We need to load a programmable filter set for undefined */
10470  /* frequencies. So we will point the filter to a programmable set. */
10471  /* Since there are only 4 filters and 4 programmable sets, we will */
10472  /* just point the filter to the same number set and program it for the */
10473  /* frequency we want. */
10474  if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10475  return -1;
10476  if (j->ver.low != 0x12) {
10477  cmd = 0x515B;
10478  max = 19;
10479  } else {
10480  cmd = 0x515E;
10481  max = 15;
10482  }
10483  if (ixj_WriteDSPCommand(cmd, j))
10484  return -1;
10485  for (cnt = 0; cnt < max; cnt++) {
10486  if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10487  return -1;
10488  }
10489  }
10490  j->filter_en[jf->filter] = jf->enable;
10491  return 0;
10492 }
10493 
10494 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10495 {
10496  unsigned short cmd;
10497  int cnt, max;
10498  if (jfr->filter > 3) {
10499  return -1;
10500  }
10501  if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10502  return -1;
10503 
10504  if (!jfr->enable) {
10505  if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10506  return -1;
10507  else
10508  return 0;
10509  } else {
10510  if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10511  return -1;
10512  /* Select the filter (f0 - f3) to use. */
10513  if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10514  return -1;
10515  }
10516  /* We need to load a programmable filter set for undefined */
10517  /* frequencies. So we will point the filter to a programmable set. */
10518  /* Since there are only 4 filters and 4 programmable sets, we will */
10519  /* just point the filter to the same number set and program it for the */
10520  /* frequency we want. */
10521  if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10522  return -1;
10523  if (j->ver.low != 0x12) {
10524  cmd = 0x515B;
10525  max = 19;
10526  } else {
10527  cmd = 0x515E;
10528  max = 15;
10529  }
10530  if (ixj_WriteDSPCommand(cmd, j))
10531  return -1;
10532  for (cnt = 0; cnt < max; cnt++) {
10533  if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10534  return -1;
10535  }
10536  j->filter_en[jfr->filter] = jfr->enable;
10537  return 0;
10538 }
10539 
10540 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10541 {
10542  int freq0, freq1;
10543  unsigned short data;
10544  if (ti->freq0) {
10545  freq0 = ti->freq0;
10546  } else {
10547  freq0 = 0x7FFF;
10548  }
10549 
10550  if (ti->freq1) {
10551  freq1 = ti->freq1;
10552  } else {
10553  freq1 = 0x7FFF;
10554  }
10555 
10556  if(ti->tone_index > 12 && ti->tone_index < 28)
10557  {
10558  if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10559  return -1;
10560  if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10561  return -1;
10562  data = freq0;
10563  if (ixj_WriteDSPCommand(data, j))
10564  return -1;
10565  data = freq1;
10566  if (ixj_WriteDSPCommand(data, j))
10567  return -1;
10568  }
10569  return freq0;
10570 }
10571 
Generated on Thu Jan 10 2013 14:31:52 for Linux Kernel by   doxygen 1.8.2