?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb: hid-core free urb cleanup
[linux/fpc-iii.git] / drivers / telephony / ixj.c
blob1b601b6cf2a2b78c148395d641955523e07b7515
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * $Log: ixj.c,v $
46 *
47 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
48 * Audit some copy_*_user and minor cleanup.
49 *
50 * Revision 4.7 2001/08/13 06:19:33 craigs
51 * Added additional changes from Alan Cox and John Anderson for
52 * 2.2 to 2.4 cleanup and bounds checking
53 *
54 * Revision 4.6 2001/08/13 01:05:05 craigs
55 * Really fixed PHONE_QUERY_CODEC problem this time
56 *
57 * Revision 4.5 2001/08/13 00:11:03 craigs
58 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
59 *
60 * Revision 4.4 2001/08/07 07:58:12 craigs
61 * Changed back to three digit version numbers
62 * Added tagbuild target to allow automatic and easy tagging of versions
63 *
64 * Revision 4.3 2001/08/07 07:24:47 craigs
65 * Added ixj-ver.h to allow easy configuration management of driver
66 * Added display of version number in /prox/ixj
67 *
68 * Revision 4.2 2001/08/06 07:07:19 craigs
69 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
70 * behaviour of returning int rather than short *
71 *
72 * Revision 4.1 2001/08/05 00:17:37 craigs
73 * More changes for correct PCMCIA installation
74 * Start of changes for backward Linux compatibility
75 *
76 * Revision 4.0 2001/08/04 12:33:12 craigs
77 * New version using GNU autoconf
78 *
79 * Revision 3.105 2001/07/20 23:14:32 eokerson
80 * More work on CallerID generation when using ring cadences.
81 *
82 * Revision 3.104 2001/07/06 01:33:55 eokerson
83 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
84 *
85 * Revision 3.103 2001/07/05 19:20:16 eokerson
86 * Updated HOWTO
87 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
88 *
89 * Revision 3.102 2001/07/03 23:51:21 eokerson
90 * Un-mute mic on Internet LineJACK when in speakerphone mode.
91 *
92 * Revision 3.101 2001/07/02 19:26:56 eokerson
93 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
94 *
95 * Revision 3.100 2001/07/02 19:18:27 eokerson
96 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
97 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
98 * Fixed speaker mode on Internet LineJACK.
99 *
100 * Revision 3.99 2001/05/09 14:11:16 eokerson
101 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
102 *
103 * Revision 3.98 2001/05/08 19:55:33 eokerson
104 * Fixed POTS hookstate detection while it is connected to PSTN port.
105 *
106 * Revision 3.97 2001/05/08 00:01:04 eokerson
107 * Fixed kernel oops when sending caller ID data.
108 *
109 * Revision 3.96 2001/05/04 23:09:30 eokerson
110 * Now uses one kernel timer for each card, instead of one for the entire driver.
111 *
112 * Revision 3.95 2001/04/25 22:06:47 eokerson
113 * Fixed squawking at beginning of some G.723.1 calls.
114 *
115 * Revision 3.94 2001/04/03 23:42:00 eokerson
116 * Added linear volume ioctls
117 * Added raw filter load ioctl
118 *
119 * Revision 3.93 2001/02/27 01:00:06 eokerson
120 * Fixed blocking in CallerID.
121 * Reduced size of ixj structure for smaller driver footprint.
122 *
123 * Revision 3.92 2001/02/20 22:02:59 eokerson
124 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
125 * Improved PSTN ring detection.
126 * Fixed wink generation on POTS ports.
127 *
128 * Revision 3.91 2001/02/13 00:55:44 eokerson
129 * Turn AEC back on after changing frame sizes.
130 *
131 * Revision 3.90 2001/02/12 16:42:00 eokerson
132 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
133 *
134 * Revision 3.89 2001/02/12 15:41:16 eokerson
135 * Fix from Artis Kugevics - Tone gains were not being set correctly.
136 *
137 * Revision 3.88 2001/02/05 23:25:42 eokerson
138 * Fixed lockup bugs with deregister.
139 *
140 * Revision 3.87 2001/01/29 21:00:39 eokerson
141 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
142 * Updated copyright date.
143 *
144 * Revision 3.86 2001/01/23 23:53:46 eokerson
145 * Fixes to G.729 compatibility.
146 *
147 * Revision 3.85 2001/01/23 21:30:36 eokerson
148 * Added verbage about cards supported.
149 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
150 *
151 * Revision 3.84 2001/01/22 23:32:10 eokerson
152 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
153 *
154 * Revision 3.83 2001/01/19 14:51:41 eokerson
155 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
156 *
157 * Revision 3.82 2001/01/19 00:34:49 eokerson
158 * Added verbosity to write overlap errors.
159 *
160 * Revision 3.81 2001/01/18 23:56:54 eokerson
161 * Fixed PSTN line test functions.
162 *
163 * Revision 3.80 2001/01/18 22:29:27 eokerson
164 * Updated AEC/AGC values for different cards.
165 *
166 * Revision 3.79 2001/01/17 02:58:54 eokerson
167 * Fixed AEC reset after Caller ID.
168 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
169 *
170 * Revision 3.78 2001/01/16 19:43:09 eokerson
171 * Added support for Linux 2.4.x kernels.
172 *
173 * Revision 3.77 2001/01/09 04:00:52 eokerson
174 * Linetest will now test the line, even if it has previously succeded.
175 *
176 * Revision 3.76 2001/01/08 19:27:00 eokerson
177 * Fixed problem with standard cable on Internet PhoneCARD.
178 *
179 * Revision 3.75 2000/12/22 16:52:14 eokerson
180 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
181 *
182 * Revision 3.74 2000/12/08 22:41:50 eokerson
183 * Added capability for G729B.
184 *
185 * Revision 3.73 2000/12/07 23:35:16 eokerson
186 * Added capability to have different ring pattern before CallerID data.
187 * Added hookstate checks in CallerID routines to stop FSK.
188 *
189 * Revision 3.72 2000/12/06 19:31:31 eokerson
190 * Modified signal behavior to only send one signal per event.
191 *
192 * Revision 3.71 2000/12/06 03:23:08 eokerson
193 * Fixed CallerID on Call Waiting.
194 *
195 * Revision 3.70 2000/12/04 21:29:37 eokerson
196 * Added checking to Smart Cable gain functions.
197 *
198 * Revision 3.69 2000/12/04 21:05:20 eokerson
199 * Changed ixjdebug levels.
200 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
201 *
202 * Revision 3.68 2000/12/04 00:17:21 craigs
203 * Changed mixer voice gain to +6dB rather than 0dB
204 *
205 * Revision 3.67 2000/11/30 21:25:51 eokerson
206 * Fixed write signal errors.
207 *
208 * Revision 3.66 2000/11/29 22:42:44 eokerson
209 * Fixed PSTN ring detect problems.
210 *
211 * Revision 3.65 2000/11/29 07:31:55 craigs
212 * Added new 425Hz filter co-efficients
213 * Added card-specific DTMF prescaler initialisation
214 *
215 * Revision 3.64 2000/11/28 14:03:32 craigs
216 * Changed certain mixer initialisations to be 0dB rather than 12dB
217 * Added additional information to /proc/ixj
218 *
219 * Revision 3.63 2000/11/28 11:38:41 craigs
220 * Added display of AEC modes in AUTO and AGC mode
221 *
222 * Revision 3.62 2000/11/28 04:05:44 eokerson
223 * Improved PSTN ring detection routine.
224 *
225 * Revision 3.61 2000/11/27 21:53:12 eokerson
226 * Fixed flash detection.
227 *
228 * Revision 3.60 2000/11/27 15:57:29 eokerson
229 * More work on G.729 load routines.
230 *
231 * Revision 3.59 2000/11/25 21:55:12 eokerson
232 * Fixed errors in G.729 load routine.
233 *
234 * Revision 3.58 2000/11/25 04:08:29 eokerson
235 * Added board locks around G.729 and TS85 load routines.
236 *
237 * Revision 3.57 2000/11/24 05:35:17 craigs
238 * Added ability to retrieve mixer values on LineJACK
239 * Added complete initialisation of all mixer values at startup
240 * Fixed spelling mistake
241 *
242 * Revision 3.56 2000/11/23 02:52:11 robertj
243 * Added cvs change log keyword.
244 * Fixed bug in capabilities list when using G.729 module.
245 *
246 */
247
248 #include "ixj-ver.h"
249
250 #define PERFMON_STATS
251 #define IXJDEBUG 0
252 #define MAXRINGS 5
253
254 #include <linux/module.h>
255
256 #include <linux/init.h>
257 #include <linux/sched.h>
258 #include <linux/kernel.h> /* printk() */
259 #include <linux/fs.h> /* everything... */
260 #include <linux/errno.h> /* error codes */
261 #include <linux/slab.h>
262 #include <linux/mm.h>
263 #include <linux/ioport.h>
264 #include <linux/interrupt.h>
265 #include <linux/proc_fs.h>
266 #include <linux/poll.h>
267 #include <linux/timer.h>
268 #include <linux/delay.h>
269 #include <linux/pci.h>
270
271 #include <asm/io.h>
272 #include <asm/uaccess.h>
273
274 #include <linux/isapnp.h>
275
276 #include "ixj.h"
277
278 #define TYPE(inode) (iminor(inode) >> 4)
279 #define NUM(inode) (iminor(inode) & 0xf)
280
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 module_param(ixjdebug, int, 0);
286
287 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
288 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
289 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
290 { }
291 };
292
293 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
294
295 /************************************************************************
296 *
297 * ixjdebug meanings are now bit mapped instead of level based
298 * Values can be or'ed together to turn on multiple messages
299 *
300 * bit 0 (0x0001) = any failure
301 * bit 1 (0x0002) = general messages
302 * bit 2 (0x0004) = POTS ringing related
303 * bit 3 (0x0008) = PSTN events
304 * bit 4 (0x0010) = PSTN Cadence state details
305 * bit 5 (0x0020) = Tone detection triggers
306 * bit 6 (0x0040) = Tone detection cadence details
307 * bit 7 (0x0080) = ioctl tracking
308 * bit 8 (0x0100) = signal tracking
309 * bit 9 (0x0200) = CallerID generation details
310 *
311 ************************************************************************/
312
313 #ifdef IXJ_DYN_ALLOC
314
315 static IXJ *ixj[IXJMAX];
316 #define get_ixj(b) ixj[(b)]
317
318 /*
319 * Allocate a free IXJ device
320 */
321
322 static IXJ *ixj_alloc()
323 {
324 for(cnt=0; cnt<IXJMAX; cnt++)
325 {
326 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
327 {
328 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
329 if (j == NULL)
330 return NULL;
331 ixj[cnt] = j;
332 return j;
333 }
334 }
335 return NULL;
336 }
337
338 static void ixj_fsk_free(IXJ *j)
339 {
340 kfree(j->fskdata);
341 j->fskdata = NULL;
342 }
343
344 static void ixj_fsk_alloc(IXJ *j)
345 {
346 if(!j->fskdata) {
347 j->fskdata = kmalloc(8000, GFP_KERNEL);
348 if (!j->fskdata) {
349 if(ixjdebug & 0x0200) {
350 printk("IXJ phone%d - allocate failed\n", j->board);
351 }
352 return;
353 } else {
354 j->fsksize = 8000;
355 if(ixjdebug & 0x0200) {
356 printk("IXJ phone%d - allocate succeded\n", j->board);
357 }
358 }
359 }
360 }
361
362 #else
363
364 static IXJ ixj[IXJMAX];
365 #define get_ixj(b) (&ixj[(b)])
366
367 /*
368 * Allocate a free IXJ device
369 */
370
371 static IXJ *ixj_alloc(void)
372 {
373 int cnt;
374 for(cnt=0; cnt<IXJMAX; cnt++) {
375 if(!ixj[cnt].DSPbase)
376 return &ixj[cnt];
377 }
378 return NULL;
379 }
380
381 static inline void ixj_fsk_free(IXJ *j) {;}
382
383 static inline void ixj_fsk_alloc(IXJ *j)
384 {
385 j->fsksize = 8000;
386 }
387
388 #endif
389
390 #ifdef PERFMON_STATS
391 #define ixj_perfmon(x) ((x)++)
392 #else
393 #define ixj_perfmon(x) do { } while(0)
394 #endif
395
396 static int ixj_convert_loaded;
397
398 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
399
400 /************************************************************************
401 *
402 * These are function definitions to allow external modules to register
403 * enhanced functionality call backs.
404 *
405 ************************************************************************/
406
407 static int Stub(IXJ * J, unsigned long arg)
408 {
409 return 0;
410 }
411
412 static IXJ_REGFUNC ixj_PreRead = &Stub;
413 static IXJ_REGFUNC ixj_PostRead = &Stub;
414 static IXJ_REGFUNC ixj_PreWrite = &Stub;
415 static IXJ_REGFUNC ixj_PostWrite = &Stub;
416
417 static void ixj_read_frame(IXJ *j);
418 static void ixj_write_frame(IXJ *j);
419 static void ixj_init_timer(IXJ *j);
420 static void ixj_add_timer(IXJ * j);
421 static void ixj_timeout(unsigned long ptr);
422 static int read_filters(IXJ *j);
423 static int LineMonitor(IXJ *j);
424 static int ixj_fasync(int fd, struct file *, int mode);
425 static int ixj_set_port(IXJ *j, int arg);
426 static int ixj_set_pots(IXJ *j, int arg);
427 static int ixj_hookstate(IXJ *j);
428 static int ixj_record_start(IXJ *j);
429 static void ixj_record_stop(IXJ *j);
430 static void set_rec_volume(IXJ *j, int volume);
431 static int get_rec_volume(IXJ *j);
432 static int set_rec_codec(IXJ *j, int rate);
433 static void ixj_vad(IXJ *j, int arg);
434 static int ixj_play_start(IXJ *j);
435 static void ixj_play_stop(IXJ *j);
436 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
437 static int ixj_set_tone_off(unsigned short, IXJ *j);
438 static int ixj_play_tone(IXJ *j, char tone);
439 static void ixj_aec_start(IXJ *j, int level);
440 static int idle(IXJ *j);
441 static void ixj_ring_on(IXJ *j);
442 static void ixj_ring_off(IXJ *j);
443 static void aec_stop(IXJ *j);
444 static void ixj_ringback(IXJ *j);
445 static void ixj_busytone(IXJ *j);
446 static void ixj_dialtone(IXJ *j);
447 static void ixj_cpt_stop(IXJ *j);
448 static char daa_int_read(IXJ *j);
449 static char daa_CR_read(IXJ *j, int cr);
450 static int daa_set_mode(IXJ *j, int mode);
451 static int ixj_linetest(IXJ *j);
452 static int ixj_daa_write(IXJ *j);
453 static int ixj_daa_cid_read(IXJ *j);
454 static void DAA_Coeff_US(IXJ *j);
455 static void DAA_Coeff_UK(IXJ *j);
456 static void DAA_Coeff_France(IXJ *j);
457 static void DAA_Coeff_Germany(IXJ *j);
458 static void DAA_Coeff_Australia(IXJ *j);
459 static void DAA_Coeff_Japan(IXJ *j);
460 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
461 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
462 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
463 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
464 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
465 /* Serial Control Interface funtions */
466 static int SCI_Control(IXJ *j, int control);
467 static int SCI_Prepare(IXJ *j);
468 static int SCI_WaitHighSCI(IXJ *j);
469 static int SCI_WaitLowSCI(IXJ *j);
470 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
471 static int ixj_PCcontrol_wait(IXJ *j);
472 static void ixj_pre_cid(IXJ *j);
473 static void ixj_write_cid(IXJ *j);
474 static void ixj_write_cid_bit(IXJ *j, int bit);
475 static int set_base_frame(IXJ *j, int size);
476 static int set_play_codec(IXJ *j, int rate);
477 static void set_rec_depth(IXJ *j, int depth);
478 static int ixj_mixer(long val, IXJ *j);
479
480 /************************************************************************
481 CT8020/CT8021 Host Programmers Model
482 Host address Function Access
483 DSPbase +
484 0-1 Aux Software Status Register (reserved) Read Only
485 2-3 Software Status Register Read Only
486 4-5 Aux Software Control Register (reserved) Read Write
487 6-7 Software Control Register Read Write
488 8-9 Hardware Status Register Read Only
489 A-B Hardware Control Register Read Write
490 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
491 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
492 ************************************************************************/
493
494 static inline void ixj_read_HSR(IXJ *j)
495 {
496 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
497 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
498 }
499
500 static inline int IsControlReady(IXJ *j)
501 {
502 ixj_read_HSR(j);
503 return j->hsr.bits.controlrdy ? 1 : 0;
504 }
505
506 static inline int IsPCControlReady(IXJ *j)
507 {
508 j->pccr1.byte = inb_p(j->XILINXbase + 3);
509 return j->pccr1.bits.crr ? 1 : 0;
510 }
511
512 static inline int IsStatusReady(IXJ *j)
513 {
514 ixj_read_HSR(j);
515 return j->hsr.bits.statusrdy ? 1 : 0;
516 }
517
518 static inline int IsRxReady(IXJ *j)
519 {
520 ixj_read_HSR(j);
521 ixj_perfmon(j->rxreadycheck);
522 return j->hsr.bits.rxrdy ? 1 : 0;
523 }
524
525 static inline int IsTxReady(IXJ *j)
526 {
527 ixj_read_HSR(j);
528 ixj_perfmon(j->txreadycheck);
529 return j->hsr.bits.txrdy ? 1 : 0;
530 }
531
532 static inline void set_play_volume(IXJ *j, int volume)
533 {
534 if (ixjdebug & 0x0002)
535 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
536 ixj_WriteDSPCommand(0xCF02, j);
537 ixj_WriteDSPCommand(volume, j);
538 }
539
540 static int set_play_volume_linear(IXJ *j, int volume)
541 {
542 int newvolume, dspplaymax;
543
544 if (ixjdebug & 0x0002)
545 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
546 if(volume > 100 || volume < 0) {
547 return -1;
548 }
549
550 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
551 switch (j->cardtype) {
552 case QTI_PHONEJACK:
553 dspplaymax = 0x380;
554 break;
555 case QTI_LINEJACK:
556 if(j->port == PORT_PSTN) {
557 dspplaymax = 0x48;
558 } else {
559 dspplaymax = 0x100;
560 }
561 break;
562 case QTI_PHONEJACK_LITE:
563 dspplaymax = 0x380;
564 break;
565 case QTI_PHONEJACK_PCI:
566 dspplaymax = 0x6C;
567 break;
568 case QTI_PHONECARD:
569 dspplaymax = 0x50;
570 break;
571 default:
572 return -1;
573 }
574 newvolume = (dspplaymax * volume) / 100;
575 set_play_volume(j, newvolume);
576 return 0;
577 }
578
579 static inline void set_play_depth(IXJ *j, int depth)
580 {
581 if (depth > 60)
582 depth = 60;
583 if (depth < 0)
584 depth = 0;
585 ixj_WriteDSPCommand(0x5280 + depth, j);
586 }
587
588 static inline int get_play_volume(IXJ *j)
589 {
590 ixj_WriteDSPCommand(0xCF00, j);
591 return j->ssr.high << 8 | j->ssr.low;
592 }
593
594 static int get_play_volume_linear(IXJ *j)
595 {
596 int volume, newvolume, dspplaymax;
597
598 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
599 switch (j->cardtype) {
600 case QTI_PHONEJACK:
601 dspplaymax = 0x380;
602 break;
603 case QTI_LINEJACK:
604 if(j->port == PORT_PSTN) {
605 dspplaymax = 0x48;
606 } else {
607 dspplaymax = 0x100;
608 }
609 break;
610 case QTI_PHONEJACK_LITE:
611 dspplaymax = 0x380;
612 break;
613 case QTI_PHONEJACK_PCI:
614 dspplaymax = 0x6C;
615 break;
616 case QTI_PHONECARD:
617 dspplaymax = 100;
618 break;
619 default:
620 return -1;
621 }
622 volume = get_play_volume(j);
623 newvolume = (volume * 100) / dspplaymax;
624 if(newvolume > 100)
625 newvolume = 100;
626 return newvolume;
627 }
628
629 static inline BYTE SLIC_GetState(IXJ *j)
630 {
631 if (j->cardtype == QTI_PHONECARD) {
632 j->pccr1.byte = 0;
633 j->psccr.bits.dev = 3;
634 j->psccr.bits.rw = 1;
635 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
636 ixj_PCcontrol_wait(j);
637 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
638 ixj_PCcontrol_wait(j);
639 if (j->pslic.bits.powerdown)
640 return PLD_SLIC_STATE_OC;
641 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
642 return PLD_SLIC_STATE_ACTIVE;
643 else
644 return PLD_SLIC_STATE_RINGING;
645 } else {
646 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
647 }
648 return j->pld_slicr.bits.state;
649 }
650
651 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
652 {
653 BOOL fRetVal = FALSE;
654
655 if (j->cardtype == QTI_PHONECARD) {
656 if (j->flags.pcmciasct) {
657 switch (byState) {
658 case PLD_SLIC_STATE_TIPOPEN:
659 case PLD_SLIC_STATE_OC:
660 j->pslic.bits.powerdown = 1;
661 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
662 fRetVal = TRUE;
663 break;
664 case PLD_SLIC_STATE_RINGING:
665 if (j->readers || j->writers) {
666 j->pslic.bits.powerdown = 0;
667 j->pslic.bits.ring0 = 1;
668 j->pslic.bits.ring1 = 0;
669 fRetVal = TRUE;
670 }
671 break;
672 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
673
674 case PLD_SLIC_STATE_STANDBY:
675 case PLD_SLIC_STATE_ACTIVE:
676 if (j->readers || j->writers) {
677 j->pslic.bits.powerdown = 0;
678 } else {
679 j->pslic.bits.powerdown = 1;
680 }
681 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
682 fRetVal = TRUE;
683 break;
684 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
685
686 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
687
688 default:
689 fRetVal = FALSE;
690 break;
691 }
692 j->psccr.bits.dev = 3;
693 j->psccr.bits.rw = 0;
694 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
695 ixj_PCcontrol_wait(j);
696 }
697 } else {
698 /* Set the C1, C2, C3 & B2EN signals. */
699 switch (byState) {
700 case PLD_SLIC_STATE_OC:
701 j->pld_slicw.bits.c1 = 0;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 0;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
706 fRetVal = TRUE;
707 break;
708 case PLD_SLIC_STATE_RINGING:
709 j->pld_slicw.bits.c1 = 1;
710 j->pld_slicw.bits.c2 = 0;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 1;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
714 fRetVal = TRUE;
715 break;
716 case PLD_SLIC_STATE_ACTIVE:
717 j->pld_slicw.bits.c1 = 0;
718 j->pld_slicw.bits.c2 = 1;
719 j->pld_slicw.bits.c3 = 0;
720 j->pld_slicw.bits.b2en = 0;
721 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
722 fRetVal = TRUE;
723 break;
724 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
725
726 j->pld_slicw.bits.c1 = 1;
727 j->pld_slicw.bits.c2 = 1;
728 j->pld_slicw.bits.c3 = 0;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
731 fRetVal = TRUE;
732 break;
733 case PLD_SLIC_STATE_TIPOPEN:
734 j->pld_slicw.bits.c1 = 0;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 0;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
739 fRetVal = TRUE;
740 break;
741 case PLD_SLIC_STATE_STANDBY:
742 j->pld_slicw.bits.c1 = 1;
743 j->pld_slicw.bits.c2 = 0;
744 j->pld_slicw.bits.c3 = 1;
745 j->pld_slicw.bits.b2en = 1;
746 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
747 fRetVal = TRUE;
748 break;
749 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
750
751 j->pld_slicw.bits.c1 = 0;
752 j->pld_slicw.bits.c2 = 1;
753 j->pld_slicw.bits.c3 = 1;
754 j->pld_slicw.bits.b2en = 0;
755 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
756 fRetVal = TRUE;
757 break;
758 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
759
760 j->pld_slicw.bits.c1 = 1;
761 j->pld_slicw.bits.c2 = 1;
762 j->pld_slicw.bits.c3 = 1;
763 j->pld_slicw.bits.b2en = 0;
764 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
765 fRetVal = TRUE;
766 break;
767 default:
768 fRetVal = FALSE;
769 break;
770 }
771 }
772
773 return fRetVal;
774 }
775
776 static int ixj_wink(IXJ *j)
777 {
778 BYTE slicnow;
779
780 slicnow = SLIC_GetState(j);
781
782 j->pots_winkstart = jiffies;
783 SLIC_SetState(PLD_SLIC_STATE_OC, j);
784
785 msleep(jiffies_to_msecs(j->winktime));
786
787 SLIC_SetState(slicnow, j);
788 return 0;
789 }
790
791 static void ixj_init_timer(IXJ *j)
792 {
793 init_timer(&j->timer);
794 j->timer.function = ixj_timeout;
795 j->timer.data = (unsigned long)j;
796 }
797
798 static void ixj_add_timer(IXJ *j)
799 {
800 j->timer.expires = jiffies + (hertz / samplerate);
801 add_timer(&j->timer);
802 }
803
804 static void ixj_tone_timeout(IXJ *j)
805 {
806 IXJ_TONE ti;
807
808 j->tone_state++;
809 if (j->tone_state == 3) {
810 j->tone_state = 0;
811 if (j->cadence_t) {
812 j->tone_cadence_state++;
813 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
814 switch (j->cadence_t->termination) {
815 case PLAY_ONCE:
816 ixj_cpt_stop(j);
817 break;
818 case REPEAT_LAST_ELEMENT:
819 j->tone_cadence_state--;
820 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
821 break;
822 case REPEAT_ALL:
823 j->tone_cadence_state = 0;
824 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
825 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
826 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
827 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
828 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
829 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
830 ixj_init_tone(j, &ti);
831 }
832 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
833 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
834 ixj_play_tone(j, j->cadence_t->ce[0].index);
835 break;
836 }
837 } else {
838 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
839 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
840 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
841 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
842 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
843 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
844 ixj_init_tone(j, &ti);
845 }
846 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
847 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
848 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
849 }
850 }
851 }
852 }
853
854 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
855 {
856 if(j->ixj_signals[event]) {
857 if(ixjdebug & 0x0100)
858 printk("Sending signal for event %d\n", event);
859 /* Send apps notice of change */
860 /* see config.h for macro definition */
861 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
862 }
863 }
864
865 static void ixj_pstn_state(IXJ *j)
866 {
867 int var;
868 union XOPXR0 XR0, daaint;
869
870 var = 10;
871
872 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
873 daaint.reg = 0;
874 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
875
876 j->pld_scrr.byte = inb_p(j->XILINXbase);
877 if (j->pld_scrr.bits.daaflag) {
878 daa_int_read(j);
879 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
880 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
881 daaint.bitreg.RING = 1;
882 if(ixjdebug & 0x0008) {
883 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
884 }
885 } else {
886 daa_set_mode(j, SOP_PU_RESET);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
890 daaint.bitreg.Caller_ID = 1;
891 j->pstn_cid_intr = 1;
892 j->pstn_cid_received = jiffies;
893 if(ixjdebug & 0x0008) {
894 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
895 }
896 }
897 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
898 daaint.bitreg.Cadence = 1;
899 if(ixjdebug & 0x0008) {
900 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
901 }
902 }
903 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
904 daaint.bitreg.VDD_OK = 1;
905 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
906 }
907 }
908 daa_CR_read(j, 1);
909 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)) {
910 daaint.bitreg.RMR = 1;
911 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
912 if(ixjdebug & 0x0008) {
913 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);
914 }
915 j->pstn_prev_rmr = j->pstn_last_rmr;
916 j->pstn_last_rmr = jiffies;
917 }
918 switch(j->daa_mode) {
919 case SOP_PU_SLEEP:
920 if (daaint.bitreg.RING) {
921 if (!j->flags.pstn_ringing) {
922 if (j->daa_mode != SOP_PU_RINGING) {
923 j->pstn_ring_int = jiffies;
924 daa_set_mode(j, SOP_PU_RINGING);
925 }
926 }
927 }
928 break;
929 case SOP_PU_RINGING:
930 if (daaint.bitreg.RMR) {
931 if (ixjdebug & 0x0008) {
932 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
933 }
934 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
935 j->flags.pstn_rmr = 1;
936 j->pstn_ring_start = jiffies;
937 j->pstn_ring_stop = 0;
938 j->ex.bits.pstn_ring = 0;
939 if (j->cadence_f[4].state == 0) {
940 j->cadence_f[4].state = 1;
941 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
942 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
943 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
944 } else if (j->cadence_f[4].state == 2) {
945 if((time_after(jiffies, j->cadence_f[4].off1min) &&
946 time_before(jiffies, j->cadence_f[4].off1max))) {
947 if (j->cadence_f[4].on2) {
948 j->cadence_f[4].state = 3;
949 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
950 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
951 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
952 } else {
953 j->cadence_f[4].state = 7;
954 }
955 } else {
956 if (ixjdebug & 0x0008) {
957 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
958 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
959 j->cadence_f[4].off1);
960 }
961 j->cadence_f[4].state = 0;
962 }
963 } else if (j->cadence_f[4].state == 4) {
964 if((time_after(jiffies, j->cadence_f[4].off2min) &&
965 time_before(jiffies, j->cadence_f[4].off2max))) {
966 if (j->cadence_f[4].on3) {
967 j->cadence_f[4].state = 5;
968 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
969 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
970 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
971 } else {
972 j->cadence_f[4].state = 7;
973 }
974 } else {
975 if (ixjdebug & 0x0008) {
976 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
977 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
978 j->cadence_f[4].off2);
979 }
980 j->cadence_f[4].state = 0;
981 }
982 } else if (j->cadence_f[4].state == 6) {
983 if((time_after(jiffies, j->cadence_f[4].off3min) &&
984 time_before(jiffies, j->cadence_f[4].off3max))) {
985 j->cadence_f[4].state = 7;
986 } else {
987 if (ixjdebug & 0x0008) {
988 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
989 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
990 j->cadence_f[4].off3);
991 }
992 j->cadence_f[4].state = 0;
993 }
994 } else {
995 j->cadence_f[4].state = 0;
996 }
997 } else { /* Falling edge of RMR */
998 j->pstn_ring_start = 0;
999 j->pstn_ring_stop = jiffies;
1000 if (j->cadence_f[4].state == 1) {
1001 if(!j->cadence_f[4].on1) {
1002 j->cadence_f[4].state = 7;
1003 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004 time_before(jiffies, j->cadence_f[4].on1max))) {
1005 if (j->cadence_f[4].off1) {
1006 j->cadence_f[4].state = 2;
1007 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010 } else {
1011 j->cadence_f[4].state = 7;
1012 }
1013 } else {
1014 if (ixjdebug & 0x0008) {
1015 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017 j->cadence_f[4].on1);
1018 }
1019 j->cadence_f[4].state = 0;
1020 }
1021 } else if (j->cadence_f[4].state == 3) {
1022 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023 time_before(jiffies, j->cadence_f[4].on2max))) {
1024 if (j->cadence_f[4].off2) {
1025 j->cadence_f[4].state = 4;
1026 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029 } else {
1030 j->cadence_f[4].state = 7;
1031 }
1032 } else {
1033 if (ixjdebug & 0x0008) {
1034 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036 j->cadence_f[4].on2);
1037 }
1038 j->cadence_f[4].state = 0;
1039 }
1040 } else if (j->cadence_f[4].state == 5) {
1041 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042 time_before(jiffies, j->cadence_f[4].on3max))) {
1043 if (j->cadence_f[4].off3) {
1044 j->cadence_f[4].state = 6;
1045 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048 } else {
1049 j->cadence_f[4].state = 7;
1050 }
1051 } else {
1052 j->cadence_f[4].state = 0;
1053 }
1054 } else {
1055 if (ixjdebug & 0x0008) {
1056 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058 j->cadence_f[4].on3);
1059 }
1060 j->cadence_f[4].state = 0;
1061 }
1062 }
1063 if (ixjdebug & 0x0010) {
1064 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065 }
1066 if (ixjdebug & 0x0010) {
1067 switch(j->cadence_f[4].state) {
1068 case 1:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071 break;
1072 case 2:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075 break;
1076 case 3:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079 break;
1080 case 4:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083 break;
1084 case 5:
1085 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087 break;
1088 case 6:
1089 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091 break;
1092 }
1093 }
1094 }
1095 if (j->cadence_f[4].state == 7) {
1096 j->cadence_f[4].state = 0;
1097 j->pstn_ring_stop = jiffies;
1098 j->ex.bits.pstn_ring = 1;
1099 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100 if(ixjdebug & 0x0008) {
1101 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102 }
1103 }
1104 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106 if(ixjdebug & 0x0008) {
1107 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110 }
1111 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112 daa_set_mode(j, SOP_PU_SLEEP);
1113 }
1114 outb_p(j->pld_scrw.byte, j->XILINXbase);
1115 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116 ixj_daa_cid_read(j);
1117 j->ex.bits.caller_id = 1;
1118 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119 j->pstn_cid_intr = 0;
1120 }
1121 if (daaint.bitreg.Cadence) {
1122 if(ixjdebug & 0x0008) {
1123 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124 }
1125 daa_set_mode(j, SOP_PU_SLEEP);
1126 j->ex.bits.pstn_ring = 0;
1127 }
1128 break;
1129 case SOP_PU_CONVERSATION:
1130 if (daaint.bitreg.VDD_OK) {
1131 if(!daaint.bitreg.SI_0) {
1132 if (!j->pstn_winkstart) {
1133 if(ixjdebug & 0x0008) {
1134 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135 }
1136 j->pstn_winkstart = jiffies;
1137 }
1138 } else {
1139 if (j->pstn_winkstart) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 j->pstn_winkstart = 0;
1144 }
1145 }
1146 }
1147 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148 if(ixjdebug & 0x0008) {
1149 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150 }
1151 daa_set_mode(j, SOP_PU_SLEEP);
1152 j->pstn_winkstart = 0;
1153 j->ex.bits.pstn_wink = 1;
1154 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155 }
1156 break;
1157 }
1158 }
1159
1160 static void ixj_timeout(unsigned long ptr)
1161 {
1162 int board;
1163 unsigned long jifon;
1164 IXJ *j = (IXJ *)ptr;
1165 board = j->board;
1166
1167 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168 ixj_perfmon(j->timerchecks);
1169 j->hookstate = ixj_hookstate(j);
1170 if (j->tone_state) {
1171 if (!(j->hookstate)) {
1172 ixj_cpt_stop(j);
1173 if (j->m_hook) {
1174 j->m_hook = 0;
1175 j->ex.bits.hookstate = 1;
1176 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177 }
1178 clear_bit(board, &j->busyflags);
1179 ixj_add_timer(j);
1180 return;
1181 }
1182 if (j->tone_state == 1)
1183 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184 else
1185 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187 if (j->tone_state == 1) {
1188 ixj_play_tone(j, j->tone_index);
1189 if (j->dsp.low == 0x20) {
1190 clear_bit(board, &j->busyflags);
1191 ixj_add_timer(j);
1192 return;
1193 }
1194 } else {
1195 ixj_play_tone(j, 0);
1196 if (j->dsp.low == 0x20) {
1197 clear_bit(board, &j->busyflags);
1198 ixj_add_timer(j);
1199 return;
1200 }
1201 }
1202 } else {
1203 ixj_tone_timeout(j);
1204 if (j->flags.dialtone) {
1205 ixj_dialtone(j);
1206 }
1207 if (j->flags.busytone) {
1208 ixj_busytone(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (j->flags.ringback) {
1216 ixj_ringback(j);
1217 if (j->dsp.low == 0x20) {
1218 clear_bit(board, &j->busyflags);
1219 ixj_add_timer(j);
1220 return;
1221 }
1222 }
1223 if (!j->tone_state) {
1224 ixj_cpt_stop(j);
1225 }
1226 }
1227 }
1228 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229 if (IsRxReady(j)) {
1230 ixj_read_frame(j);
1231 }
1232 if (IsTxReady(j)) {
1233 ixj_write_frame(j);
1234 }
1235 }
1236 if (j->flags.cringing) {
1237 if (j->hookstate & 1) {
1238 j->flags.cringing = 0;
1239 ixj_ring_off(j);
1240 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241 switch(j->cadence_f[5].state) {
1242 case 0:
1243 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245 if(ixjdebug & 0x0004) {
1246 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247 }
1248 ixj_ring_on(j);
1249 }
1250 j->cadence_f[5].state = 1;
1251 break;
1252 case 1:
1253 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255 if(ixjdebug & 0x0004) {
1256 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257 }
1258 ixj_ring_off(j);
1259 j->cadence_f[5].state = 2;
1260 }
1261 break;
1262 case 2:
1263 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264 if(ixjdebug & 0x0004) {
1265 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266 }
1267 ixj_ring_on(j);
1268 if (j->cadence_f[5].on2) {
1269 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270 j->cadence_f[5].state = 3;
1271 } else {
1272 j->cadence_f[5].state = 7;
1273 }
1274 }
1275 break;
1276 case 3:
1277 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278 if(ixjdebug & 0x0004) {
1279 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280 }
1281 ixj_ring_off(j);
1282 if (j->cadence_f[5].off2) {
1283 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284 j->cadence_f[5].state = 4;
1285 } else {
1286 j->cadence_f[5].state = 7;
1287 }
1288 }
1289 break;
1290 case 4:
1291 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292 if(ixjdebug & 0x0004) {
1293 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294 }
1295 ixj_ring_on(j);
1296 if (j->cadence_f[5].on3) {
1297 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298 j->cadence_f[5].state = 5;
1299 } else {
1300 j->cadence_f[5].state = 7;
1301 }
1302 }
1303 break;
1304 case 5:
1305 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306 if(ixjdebug & 0x0004) {
1307 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308 }
1309 ixj_ring_off(j);
1310 if (j->cadence_f[5].off3) {
1311 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312 j->cadence_f[5].state = 6;
1313 } else {
1314 j->cadence_f[5].state = 7;
1315 }
1316 }
1317 break;
1318 case 6:
1319 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320 if(ixjdebug & 0x0004) {
1321 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322 }
1323 j->cadence_f[5].state = 7;
1324 }
1325 break;
1326 case 7:
1327 if(ixjdebug & 0x0004) {
1328 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329 }
1330 j->flags.cidring = 1;
1331 j->cadence_f[5].state = 0;
1332 break;
1333 }
1334 if (j->flags.cidring && !j->flags.cidsent) {
1335 j->flags.cidsent = 1;
1336 if(j->fskdcnt) {
1337 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338 ixj_pre_cid(j);
1339 }
1340 j->flags.cidring = 0;
1341 }
1342 clear_bit(board, &j->busyflags);
1343 ixj_add_timer(j);
1344 return;
1345 } else {
1346 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347 if (j->flags.cidring && !j->flags.cidsent) {
1348 j->flags.cidsent = 1;
1349 if(j->fskdcnt) {
1350 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351 ixj_pre_cid(j);
1352 }
1353 j->flags.cidring = 0;
1354 }
1355 j->ring_cadence_t--;
1356 if (j->ring_cadence_t == -1)
1357 j->ring_cadence_t = 15;
1358 j->ring_cadence_jif = jiffies;
1359
1360 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362 j->flags.firstring = 1;
1363 else
1364 ixj_ring_on(j);
1365 } else {
1366 ixj_ring_off(j);
1367 if(!j->flags.cidsent)
1368 j->flags.cidring = 1;
1369 }
1370 }
1371 clear_bit(board, &j->busyflags);
1372 ixj_add_timer(j);
1373 return;
1374 }
1375 }
1376 if (!j->flags.ringing) {
1377 if (j->hookstate) { /* & 1) { */
1378 if (j->dsp.low != 0x20 &&
1379 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381 }
1382 LineMonitor(j);
1383 read_filters(j);
1384 ixj_WriteDSPCommand(0x511B, j);
1385 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386 if (!j->m_hook && (j->hookstate & 1)) {
1387 j->m_hook = j->ex.bits.hookstate = 1;
1388 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389 }
1390 } else {
1391 if (j->ex.bits.dtmf_ready) {
1392 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393 }
1394 if (j->m_hook) {
1395 j->m_hook = 0;
1396 j->ex.bits.hookstate = 1;
1397 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398 }
1399 }
1400 }
1401 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402 ixj_pstn_state(j);
1403 }
1404 if (j->ex.bytes) {
1405 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1406 }
1407 clear_bit(board, &j->busyflags);
1408 }
1409 ixj_add_timer(j);
1410 }
1411
1412 static int ixj_status_wait(IXJ *j)
1413 {
1414 unsigned long jif;
1415
1416 jif = jiffies + ((60 * hertz) / 100);
1417 while (!IsStatusReady(j)) {
1418 ixj_perfmon(j->statuswait);
1419 if (time_after(jiffies, jif)) {
1420 ixj_perfmon(j->statuswaitfail);
1421 return -1;
1422 }
1423 }
1424 return 0;
1425 }
1426
1427 static int ixj_PCcontrol_wait(IXJ *j)
1428 {
1429 unsigned long jif;
1430
1431 jif = jiffies + ((60 * hertz) / 100);
1432 while (!IsPCControlReady(j)) {
1433 ixj_perfmon(j->pcontrolwait);
1434 if (time_after(jiffies, jif)) {
1435 ixj_perfmon(j->pcontrolwaitfail);
1436 return -1;
1437 }
1438 }
1439 return 0;
1440 }
1441
1442 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443 {
1444 BYTES bytes;
1445 unsigned long jif;
1446
1447 atomic_inc(&j->DSPWrite);
1448 if(atomic_read(&j->DSPWrite) > 1) {
1449 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450 return -1;
1451 }
1452 bytes.high = (cmd & 0xFF00) >> 8;
1453 bytes.low = cmd & 0x00FF;
1454 jif = jiffies + ((60 * hertz) / 100);
1455 while (!IsControlReady(j)) {
1456 ixj_perfmon(j->iscontrolready);
1457 if (time_after(jiffies, jif)) {
1458 ixj_perfmon(j->iscontrolreadyfail);
1459 atomic_dec(&j->DSPWrite);
1460 if(atomic_read(&j->DSPWrite) > 0) {
1461 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462 while(atomic_read(&j->DSPWrite) > 0) {
1463 atomic_dec(&j->DSPWrite);
1464 }
1465 }
1466 return -1;
1467 }
1468 }
1469 outb(bytes.low, j->DSPbase + 6);
1470 outb(bytes.high, j->DSPbase + 7);
1471
1472 if (ixj_status_wait(j)) {
1473 j->ssr.low = 0xFF;
1474 j->ssr.high = 0xFF;
1475 atomic_dec(&j->DSPWrite);
1476 if(atomic_read(&j->DSPWrite) > 0) {
1477 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478 while(atomic_read(&j->DSPWrite) > 0) {
1479 atomic_dec(&j->DSPWrite);
1480 }
1481 }
1482 return -1;
1483 }
1484 /* Read Software Status Register */
1485 j->ssr.low = inb_p(j->DSPbase + 2);
1486 j->ssr.high = inb_p(j->DSPbase + 3);
1487 atomic_dec(&j->DSPWrite);
1488 if(atomic_read(&j->DSPWrite) > 0) {
1489 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490 while(atomic_read(&j->DSPWrite) > 0) {
1491 atomic_dec(&j->DSPWrite);
1492 }
1493 }
1494 return 0;
1495 }
1496
1497 /***************************************************************************
1498 *
1499 * General Purpose IO Register read routine
1500 *
1501 ***************************************************************************/
1502 static inline int ixj_gpio_read(IXJ *j)
1503 {
1504 if (ixj_WriteDSPCommand(0x5143, j))
1505 return -1;
1506
1507 j->gpio.bytes.low = j->ssr.low;
1508 j->gpio.bytes.high = j->ssr.high;
1509
1510 return 0;
1511 }
1512
1513 static inline void LED_SetState(int state, IXJ *j)
1514 {
1515 if (j->cardtype == QTI_LINEJACK) {
1516 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521 outb(j->pld_scrw.byte, j->XILINXbase);
1522 }
1523 }
1524
1525 /*********************************************************************
1526 * GPIO Pins are configured as follows on the Quicknet Internet
1527 * PhoneJACK Telephony Cards
1528 *
1529 * POTS Select GPIO_6=0 GPIO_7=0
1530 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531 * Handset Select GPIO_6=1 GPIO_7=0
1532 *
1533 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1534 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1535 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1536 *
1537 * Hook Switch changes reported on GPIO_3
1538 *********************************************************************/
1539 static int ixj_set_port(IXJ *j, int arg)
1540 {
1541 if (j->cardtype == QTI_PHONEJACK_LITE) {
1542 if (arg != PORT_POTS)
1543 return 10;
1544 else
1545 return 0;
1546 }
1547 switch (arg) {
1548 case PORT_POTS:
1549 j->port = PORT_POTS;
1550 switch (j->cardtype) {
1551 case QTI_PHONECARD:
1552 if (j->flags.pcmciasct == 1)
1553 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554 else
1555 return 11;
1556 break;
1557 case QTI_PHONEJACK_PCI:
1558 j->pld_slicw.pcib.mic = 0;
1559 j->pld_slicw.pcib.spk = 0;
1560 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561 break;
1562 case QTI_LINEJACK:
1563 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1564 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1565 Software Control Register */
1566 return 2;
1567 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1568
1569 outb(j->pld_scrw.byte, j->XILINXbase);
1570 j->pld_clock.byte = 0;
1571 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572 j->pld_slicw.bits.rly1 = 1;
1573 j->pld_slicw.bits.spken = 0;
1574 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1576 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1577 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1578 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1579 ixj_mixer(0x0E80, j); /*Mic mute */
1580 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1581 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1582 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1583 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585 break;
1586 case QTI_PHONEJACK:
1587 j->gpio.bytes.high = 0x0B;
1588 j->gpio.bits.gpio6 = 0;
1589 j->gpio.bits.gpio7 = 0;
1590 ixj_WriteDSPCommand(j->gpio.word, j);
1591 break;
1592 }
1593 break;
1594 case PORT_PSTN:
1595 if (j->cardtype == QTI_LINEJACK) {
1596 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598 j->pld_slicw.bits.rly3 = 0;
1599 j->pld_slicw.bits.rly1 = 1;
1600 j->pld_slicw.bits.spken = 0;
1601 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602 j->port = PORT_PSTN;
1603 } else {
1604 return 4;
1605 }
1606 break;
1607 case PORT_SPEAKER:
1608 j->port = PORT_SPEAKER;
1609 switch (j->cardtype) {
1610 case QTI_PHONECARD:
1611 if (j->flags.pcmciasct) {
1612 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613 }
1614 break;
1615 case QTI_PHONEJACK_PCI:
1616 j->pld_slicw.pcib.mic = 1;
1617 j->pld_slicw.pcib.spk = 1;
1618 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619 break;
1620 case QTI_LINEJACK:
1621 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1622 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1623 Software Control Register */
1624 return 2;
1625 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1626
1627 outb(j->pld_scrw.byte, j->XILINXbase);
1628 j->pld_clock.byte = 0;
1629 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630 j->pld_slicw.bits.rly1 = 1;
1631 j->pld_slicw.bits.spken = 1;
1632 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1634 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1635 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1636 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1637 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1638 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1639 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1640 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1641 break;
1642 case QTI_PHONEJACK:
1643 j->gpio.bytes.high = 0x0B;
1644 j->gpio.bits.gpio6 = 0;
1645 j->gpio.bits.gpio7 = 1;
1646 ixj_WriteDSPCommand(j->gpio.word, j);
1647 break;
1648 }
1649 break;
1650 case PORT_HANDSET:
1651 if (j->cardtype != QTI_PHONEJACK) {
1652 return 5;
1653 } else {
1654 j->gpio.bytes.high = 0x0B;
1655 j->gpio.bits.gpio6 = 1;
1656 j->gpio.bits.gpio7 = 0;
1657 ixj_WriteDSPCommand(j->gpio.word, j);
1658 j->port = PORT_HANDSET;
1659 }
1660 break;
1661 default:
1662 return 6;
1663 break;
1664 }
1665 return 0;
1666 }
1667
1668 static int ixj_set_pots(IXJ *j, int arg)
1669 {
1670 if (j->cardtype == QTI_LINEJACK) {
1671 if (arg) {
1672 if (j->port == PORT_PSTN) {
1673 j->pld_slicw.bits.rly1 = 0;
1674 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675 j->flags.pots_pstn = 1;
1676 return 1;
1677 } else {
1678 j->flags.pots_pstn = 0;
1679 return 0;
1680 }
1681 } else {
1682 j->pld_slicw.bits.rly1 = 1;
1683 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684 j->flags.pots_pstn = 0;
1685 return 1;
1686 }
1687 } else {
1688 return 0;
1689 }
1690 }
1691
1692 static void ixj_ring_on(IXJ *j)
1693 {
1694 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695 {
1696 if (ixjdebug & 0x0004)
1697 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1698
1699 j->gpio.bytes.high = 0x0B;
1700 j->gpio.bytes.low = 0x00;
1701 j->gpio.bits.gpio1 = 1;
1702 j->gpio.bits.gpio2 = 1;
1703 j->gpio.bits.gpio5 = 0;
1704 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1705 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706 {
1707 if (ixjdebug & 0x0004)
1708 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711 }
1712 }
1713
1714 static int ixj_siadc(IXJ *j, int val)
1715 {
1716 if(j->cardtype == QTI_PHONECARD){
1717 if(j->flags.pcmciascp){
1718 if(val == -1)
1719 return j->siadc.bits.rxg;
1720
1721 if(val < 0 || val > 0x1F)
1722 return -1;
1723
1724 j->siadc.bits.hom = 0; /* Handset Out Mute */
1725 j->siadc.bits.lom = 0; /* Line Out Mute */
1726 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1727 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1728 j->psccr.bits.rw = 0; /* Read / Write flag */
1729 j->psccr.bits.dev = 0;
1730 outb(j->siadc.byte, j->XILINXbase + 0x00);
1731 outb(j->psccr.byte, j->XILINXbase + 0x01);
1732 ixj_PCcontrol_wait(j);
1733 return j->siadc.bits.rxg;
1734 }
1735 }
1736 return -1;
1737 }
1738
1739 static int ixj_sidac(IXJ *j, int val)
1740 {
1741 if(j->cardtype == QTI_PHONECARD){
1742 if(j->flags.pcmciascp){
1743 if(val == -1)
1744 return j->sidac.bits.txg;
1745
1746 if(val < 0 || val > 0x1F)
1747 return -1;
1748
1749 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1750 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1751 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1752 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1753 j->psccr.bits.rw = 0; /* Read / Write flag */
1754 j->psccr.bits.dev = 0;
1755 outb(j->sidac.byte, j->XILINXbase + 0x00);
1756 outb(j->psccr.byte, j->XILINXbase + 0x01);
1757 ixj_PCcontrol_wait(j);
1758 return j->sidac.bits.txg;
1759 }
1760 }
1761 return -1;
1762 }
1763
1764 static int ixj_pcmcia_cable_check(IXJ *j)
1765 {
1766 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767 if (!j->flags.pcmciastate) {
1768 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770 j->flags.pcmciastate = 4;
1771 return 0;
1772 }
1773 if (j->pccr1.bits.ed) {
1774 j->pccr1.bits.ed = 0;
1775 j->psccr.bits.dev = 3;
1776 j->psccr.bits.rw = 1;
1777 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778 ixj_PCcontrol_wait(j);
1779 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781 j->psccr.bits.dev = 3;
1782 j->psccr.bits.rw = 0;
1783 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784 ixj_PCcontrol_wait(j);
1785 return j->pslic.bits.led2 ? 1 : 0;
1786 } else if (j->flags.pcmciasct) {
1787 return j->r_hook;
1788 } else {
1789 return 1;
1790 }
1791 } else if (j->flags.pcmciastate == 4) {
1792 if (!j->pccr1.bits.drf) {
1793 j->flags.pcmciastate = 3;
1794 }
1795 return 0;
1796 } else if (j->flags.pcmciastate == 3) {
1797 j->pccr2.bits.pwr = 0;
1798 j->pccr2.bits.rstc = 1;
1799 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800 j->checkwait = jiffies + (hertz * 2);
1801 j->flags.incheck = 1;
1802 j->flags.pcmciastate = 2;
1803 return 0;
1804 } else if (j->flags.pcmciastate == 2) {
1805 if (j->flags.incheck) {
1806 if (time_before(jiffies, j->checkwait)) {
1807 return 0;
1808 } else {
1809 j->flags.incheck = 0;
1810 }
1811 }
1812 j->pccr2.bits.pwr = 0;
1813 j->pccr2.bits.rstc = 0;
1814 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815 j->flags.pcmciastate = 1;
1816 return 0;
1817 } else if (j->flags.pcmciastate == 1) {
1818 j->flags.pcmciastate = 0;
1819 if (!j->pccr1.bits.drf) {
1820 j->psccr.bits.dev = 3;
1821 j->psccr.bits.rw = 1;
1822 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823 ixj_PCcontrol_wait(j);
1824 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1825
1826 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1827
1828 if (j->flags.pcmciasct == 3) {
1829 j->flags.pcmciastate = 4;
1830 return 0;
1831 } else if (j->flags.pcmciasct == 0) {
1832 j->pccr2.bits.pwr = 1;
1833 j->pccr2.bits.rstc = 0;
1834 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835 j->port = PORT_SPEAKER;
1836 } else {
1837 j->port = PORT_POTS;
1838 }
1839 j->sic1.bits.cpd = 0; /* Chip Power Down */
1840 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1841 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1842 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1843 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1844 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1845 j->psccr.bits.rw = 0; /* Read / Write flag */
1846 j->psccr.bits.dev = 0;
1847 outb(j->sic1.byte, j->XILINXbase + 0x00);
1848 outb(j->psccr.byte, j->XILINXbase + 0x01);
1849 ixj_PCcontrol_wait(j);
1850
1851 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1852 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1853 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1854 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1855 j->sic2.bits.hpd = 0; /* HPF disable */
1856 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1857 j->psccr.bits.rw = 0; /* Read / Write flag */
1858 j->psccr.bits.dev = 0;
1859 outb(j->sic2.byte, j->XILINXbase + 0x00);
1860 outb(j->psccr.byte, j->XILINXbase + 0x01);
1861 ixj_PCcontrol_wait(j);
1862
1863 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1864 j->psccr.bits.rw = 0; /* Read / Write flag */
1865 j->psccr.bits.dev = 0;
1866 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1867 outb(j->psccr.byte, j->XILINXbase + 0x01);
1868 ixj_PCcontrol_wait(j);
1869
1870 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1871 j->psccr.bits.rw = 0; /* Read / Write flag */
1872 j->psccr.bits.dev = 0;
1873 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1874 outb(j->psccr.byte, j->XILINXbase + 0x01);
1875 ixj_PCcontrol_wait(j);
1876
1877 j->sirxg.bits.lig = 1; /* Line In Gain */
1878 j->sirxg.bits.lim = 1; /* Line In Mute */
1879 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1880 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1881 j->sirxg.bits.him = 0; /* Handset In Mute */
1882 j->sirxg.bits.iir = 1; /* IIR */
1883 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1884 j->psccr.bits.rw = 0; /* Read / Write flag */
1885 j->psccr.bits.dev = 0;
1886 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887 outb(j->psccr.byte, j->XILINXbase + 0x01);
1888 ixj_PCcontrol_wait(j);
1889
1890 ixj_siadc(j, 0x17);
1891 ixj_sidac(j, 0x1D);
1892
1893 j->siaatt.bits.sot = 0;
1894 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1895 j->psccr.bits.rw = 0; /* Read / Write flag */
1896 j->psccr.bits.dev = 0;
1897 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898 outb(j->psccr.byte, j->XILINXbase + 0x01);
1899 ixj_PCcontrol_wait(j);
1900
1901 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902 j->psccr.byte = j->pslic.byte = 0;
1903 j->pslic.bits.powerdown = 1;
1904 j->psccr.bits.dev = 3;
1905 j->psccr.bits.rw = 0;
1906 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907 ixj_PCcontrol_wait(j);
1908 }
1909 }
1910 return 0;
1911 } else {
1912 j->flags.pcmciascp = 0;
1913 return 0;
1914 }
1915 return 0;
1916 }
1917
1918 static int ixj_hookstate(IXJ *j)
1919 {
1920 int fOffHook = 0;
1921
1922 switch (j->cardtype) {
1923 case QTI_PHONEJACK:
1924 ixj_gpio_read(j);
1925 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1926 break;
1927 case QTI_LINEJACK:
1928 case QTI_PHONEJACK_LITE:
1929 case QTI_PHONEJACK_PCI:
1930 SLIC_GetState(j);
1931 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1932 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1933 if(fOffHook != j->p_hook) {
1934 if(!j->checkwait) {
1935 j->checkwait = jiffies;
1936 }
1937 if(time_before(jiffies, j->checkwait + 2)) {
1938 fOffHook ^= 1;
1939 } else {
1940 j->checkwait = 0;
1941 }
1942 j->p_hook = fOffHook;
1943 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1944 }
1945 } else {
1946 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1947 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1948 if (j->flags.ringing || j->flags.cringing) {
1949 if (!in_interrupt()) {
1950 msleep(20);
1951 }
1952 SLIC_GetState(j);
1953 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1954 ixj_ring_on(j);
1955 }
1956 }
1957 if (j->cardtype == QTI_PHONEJACK_PCI) {
1958 j->pld_scrr.byte = inb_p(j->XILINXbase);
1959 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1960 } else
1961 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1962 }
1963 }
1964 break;
1965 case QTI_PHONECARD:
1966 fOffHook = ixj_pcmcia_cable_check(j);
1967 break;
1968 }
1969 if (j->r_hook != fOffHook) {
1970 j->r_hook = fOffHook;
1971 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1972 j->ex.bits.hookstate = 1;
1973 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1974 } else if (!fOffHook) {
1975 j->flash_end = jiffies + ((60 * hertz) / 100);
1976 }
1977 }
1978 if (fOffHook) {
1979 if(time_before(jiffies, j->flash_end)) {
1980 j->ex.bits.flash = 1;
1981 j->flash_end = 0;
1982 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1983 }
1984 } else {
1985 if(time_before(jiffies, j->flash_end)) {
1986 fOffHook = 1;
1987 }
1988 }
1989
1990 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1991 fOffHook |= 2;
1992
1993 if (j->port == PORT_SPEAKER) {
1994 if(j->cardtype == QTI_PHONECARD) {
1995 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1996 fOffHook |= 2;
1997 }
1998 } else {
1999 fOffHook |= 2;
2000 }
2001 }
2002
2003 if (j->port == PORT_HANDSET)
2004 fOffHook |= 2;
2005
2006 return fOffHook;
2007 }
2008
2009 static void ixj_ring_off(IXJ *j)
2010 {
2011 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2012 {
2013 if (ixjdebug & 0x0004)
2014 printk(KERN_INFO "IXJ Ring Off\n");
2015 j->gpio.bytes.high = 0x0B;
2016 j->gpio.bytes.low = 0x00;
2017 j->gpio.bits.gpio1 = 0;
2018 j->gpio.bits.gpio2 = 1;
2019 j->gpio.bits.gpio5 = 0;
2020 ixj_WriteDSPCommand(j->gpio.word, j);
2021 } else /* Internet LineJACK */
2022 {
2023 if (ixjdebug & 0x0004)
2024 printk(KERN_INFO "IXJ Ring Off\n");
2025
2026 if(!j->flags.cidplay)
2027 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2028
2029 SLIC_GetState(j);
2030 }
2031 }
2032
2033 static void ixj_ring_start(IXJ *j)
2034 {
2035 j->flags.cringing = 1;
2036 if (ixjdebug & 0x0004)
2037 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2038 if (ixj_hookstate(j) & 1) {
2039 if (j->port == PORT_POTS)
2040 ixj_ring_off(j);
2041 j->flags.cringing = 0;
2042 if (ixjdebug & 0x0004)
2043 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2044 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2045 j->ring_cadence_jif = jiffies;
2046 j->flags.cidsent = j->flags.cidring = 0;
2047 j->cadence_f[5].state = 0;
2048 if(j->cadence_f[5].on1)
2049 ixj_ring_on(j);
2050 } else {
2051 j->ring_cadence_jif = jiffies;
2052 j->ring_cadence_t = 15;
2053 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2054 ixj_ring_on(j);
2055 } else {
2056 ixj_ring_off(j);
2057 }
2058 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2059 }
2060 }
2061
2062 static int ixj_ring(IXJ *j)
2063 {
2064 char cntr;
2065 unsigned long jif;
2066
2067 j->flags.ringing = 1;
2068 if (ixj_hookstate(j) & 1) {
2069 ixj_ring_off(j);
2070 j->flags.ringing = 0;
2071 return 1;
2072 }
2073 for (cntr = 0; cntr < j->maxrings; cntr++) {
2074 jif = jiffies + (1 * hertz);
2075 ixj_ring_on(j);
2076 while (time_before(jiffies, jif)) {
2077 if (ixj_hookstate(j) & 1) {
2078 ixj_ring_off(j);
2079 j->flags.ringing = 0;
2080 return 1;
2081 }
2082 schedule_timeout_interruptible(1);
2083 if (signal_pending(current))
2084 break;
2085 }
2086 jif = jiffies + (3 * hertz);
2087 ixj_ring_off(j);
2088 while (time_before(jiffies, jif)) {
2089 if (ixj_hookstate(j) & 1) {
2090 msleep(10);
2091 if (ixj_hookstate(j) & 1) {
2092 j->flags.ringing = 0;
2093 return 1;
2094 }
2095 }
2096 schedule_timeout_interruptible(1);
2097 if (signal_pending(current))
2098 break;
2099 }
2100 }
2101 ixj_ring_off(j);
2102 j->flags.ringing = 0;
2103 return 0;
2104 }
2105
2106 static int ixj_open(struct phone_device *p, struct file *file_p)
2107 {
2108 IXJ *j = get_ixj(p->board);
2109 file_p->private_data = j;
2110
2111 if (!j->DSPbase)
2112 return -ENODEV;
2113
2114 if (file_p->f_mode & FMODE_READ) {
2115 if(!j->readers) {
2116 j->readers++;
2117 } else {
2118 return -EBUSY;
2119 }
2120 }
2121
2122 if (file_p->f_mode & FMODE_WRITE) {
2123 if(!j->writers) {
2124 j->writers++;
2125 } else {
2126 if (file_p->f_mode & FMODE_READ){
2127 j->readers--;
2128 }
2129 return -EBUSY;
2130 }
2131 }
2132
2133 if (j->cardtype == QTI_PHONECARD) {
2134 j->pslic.bits.powerdown = 0;
2135 j->psccr.bits.dev = 3;
2136 j->psccr.bits.rw = 0;
2137 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2138 ixj_PCcontrol_wait(j);
2139 }
2140
2141 j->flags.cidplay = 0;
2142 j->flags.cidcw_ack = 0;
2143
2144 if (ixjdebug & 0x0002)
2145 printk(KERN_INFO "Opening board %d\n", p->board);
2146
2147 j->framesread = j->frameswritten = 0;
2148 return 0;
2149 }
2150
2151 static int ixj_release(struct inode *inode, struct file *file_p)
2152 {
2153 IXJ_TONE ti;
2154 int cnt;
2155 IXJ *j = file_p->private_data;
2156 int board = j->p.board;
2157
2158 /*
2159 * Set up locks to ensure that only one process is talking to the DSP at a time.
2160 * This is necessary to keep the DSP from locking up.
2161 */
2162 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2163 schedule_timeout_interruptible(1);
2164 if (ixjdebug & 0x0002)
2165 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2166
2167 if (j->cardtype == QTI_PHONECARD)
2168 ixj_set_port(j, PORT_SPEAKER);
2169 else
2170 ixj_set_port(j, PORT_POTS);
2171
2172 aec_stop(j);
2173 ixj_play_stop(j);
2174 ixj_record_stop(j);
2175 set_play_volume(j, 0x100);
2176 set_rec_volume(j, 0x100);
2177 ixj_ring_off(j);
2178
2179 /* Restore the tone table to default settings. */
2180 ti.tone_index = 10;
2181 ti.gain0 = 1;
2182 ti.freq0 = hz941;
2183 ti.gain1 = 0;
2184 ti.freq1 = hz1209;
2185 ixj_init_tone(j, &ti);
2186 ti.tone_index = 11;
2187 ti.gain0 = 1;
2188 ti.freq0 = hz941;
2189 ti.gain1 = 0;
2190 ti.freq1 = hz1336;
2191 ixj_init_tone(j, &ti);
2192 ti.tone_index = 12;
2193 ti.gain0 = 1;
2194 ti.freq0 = hz941;
2195 ti.gain1 = 0;
2196 ti.freq1 = hz1477;
2197 ixj_init_tone(j, &ti);
2198 ti.tone_index = 13;
2199 ti.gain0 = 1;
2200 ti.freq0 = hz800;
2201 ti.gain1 = 0;
2202 ti.freq1 = 0;
2203 ixj_init_tone(j, &ti);
2204 ti.tone_index = 14;
2205 ti.gain0 = 1;
2206 ti.freq0 = hz1000;
2207 ti.gain1 = 0;
2208 ti.freq1 = 0;
2209 ixj_init_tone(j, &ti);
2210 ti.tone_index = 15;
2211 ti.gain0 = 1;
2212 ti.freq0 = hz1250;
2213 ti.gain1 = 0;
2214 ti.freq1 = 0;
2215 ixj_init_tone(j, &ti);
2216 ti.tone_index = 16;
2217 ti.gain0 = 1;
2218 ti.freq0 = hz950;
2219 ti.gain1 = 0;
2220 ti.freq1 = 0;
2221 ixj_init_tone(j, &ti);
2222 ti.tone_index = 17;
2223 ti.gain0 = 1;
2224 ti.freq0 = hz1100;
2225 ti.gain1 = 0;
2226 ti.freq1 = 0;
2227 ixj_init_tone(j, &ti);
2228 ti.tone_index = 18;
2229 ti.gain0 = 1;
2230 ti.freq0 = hz1400;
2231 ti.gain1 = 0;
2232 ti.freq1 = 0;
2233 ixj_init_tone(j, &ti);
2234 ti.tone_index = 19;
2235 ti.gain0 = 1;
2236 ti.freq0 = hz1500;
2237 ti.gain1 = 0;
2238 ti.freq1 = 0;
2239 ixj_init_tone(j, &ti);
2240 ti.tone_index = 20;
2241 ti.gain0 = 1;
2242 ti.freq0 = hz1600;
2243 ti.gain1 = 0;
2244 ti.freq1 = 0;
2245 ixj_init_tone(j, &ti);
2246 ti.tone_index = 21;
2247 ti.gain0 = 1;
2248 ti.freq0 = hz1800;
2249 ti.gain1 = 0;
2250 ti.freq1 = 0;
2251 ixj_init_tone(j, &ti);
2252 ti.tone_index = 22;
2253 ti.gain0 = 1;
2254 ti.freq0 = hz2100;
2255 ti.gain1 = 0;
2256 ti.freq1 = 0;
2257 ixj_init_tone(j, &ti);
2258 ti.tone_index = 23;
2259 ti.gain0 = 1;
2260 ti.freq0 = hz1300;
2261 ti.gain1 = 0;
2262 ti.freq1 = 0;
2263 ixj_init_tone(j, &ti);
2264 ti.tone_index = 24;
2265 ti.gain0 = 1;
2266 ti.freq0 = hz2450;
2267 ti.gain1 = 0;
2268 ti.freq1 = 0;
2269 ixj_init_tone(j, &ti);
2270 ti.tone_index = 25;
2271 ti.gain0 = 1;
2272 ti.freq0 = hz350;
2273 ti.gain1 = 0;
2274 ti.freq1 = hz440;
2275 ixj_init_tone(j, &ti);
2276 ti.tone_index = 26;
2277 ti.gain0 = 1;
2278 ti.freq0 = hz440;
2279 ti.gain1 = 0;
2280 ti.freq1 = hz480;
2281 ixj_init_tone(j, &ti);
2282 ti.tone_index = 27;
2283 ti.gain0 = 1;
2284 ti.freq0 = hz480;
2285 ti.gain1 = 0;
2286 ti.freq1 = hz620;
2287 ixj_init_tone(j, &ti);
2288
2289 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2290
2291 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2292
2293 j->ex.bits.dtmf_ready = 0;
2294 j->dtmf_state = 0;
2295 j->dtmf_wp = j->dtmf_rp = 0;
2296 j->rec_mode = j->play_mode = -1;
2297 j->flags.ringing = 0;
2298 j->maxrings = MAXRINGS;
2299 j->ring_cadence = USA_RING_CADENCE;
2300 if(j->cadence_f[5].enable) {
2301 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2302 }
2303 j->drybuffer = 0;
2304 j->winktime = 320;
2305 j->flags.dtmf_oob = 0;
2306 for (cnt = 0; cnt < 4; cnt++)
2307 j->cadence_f[cnt].enable = 0;
2308
2309 idle(j);
2310
2311 if(j->cardtype == QTI_PHONECARD) {
2312 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2313 }
2314
2315 if (file_p->f_mode & FMODE_READ)
2316 j->readers--;
2317 if (file_p->f_mode & FMODE_WRITE)
2318 j->writers--;
2319
2320 if (j->read_buffer && !j->readers) {
2321 kfree(j->read_buffer);
2322 j->read_buffer = NULL;
2323 j->read_buffer_size = 0;
2324 }
2325 if (j->write_buffer && !j->writers) {
2326 kfree(j->write_buffer);
2327 j->write_buffer = NULL;
2328 j->write_buffer_size = 0;
2329 }
2330 j->rec_codec = j->play_codec = 0;
2331 j->rec_frame_size = j->play_frame_size = 0;
2332 j->flags.cidsent = j->flags.cidring = 0;
2333 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2334
2335 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2336 ixj_set_port(j, PORT_PSTN);
2337 daa_set_mode(j, SOP_PU_SLEEP);
2338 ixj_set_pots(j, 1);
2339 }
2340 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2341
2342 /* Set up the default signals for events */
2343 for (cnt = 0; cnt < 35; cnt++)
2344 j->ixj_signals[cnt] = SIGIO;
2345
2346 /* Set the excetion signal enable flags */
2347 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2348 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 =
2349 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;
2350
2351 file_p->private_data = NULL;
2352 clear_bit(board, &j->busyflags);
2353 return 0;
2354 }
2355
2356 static int read_filters(IXJ *j)
2357 {
2358 unsigned short fc, cnt, trg;
2359 int var;
2360
2361 trg = 0;
2362 if (ixj_WriteDSPCommand(0x5144, j)) {
2363 if(ixjdebug & 0x0001) {
2364 printk(KERN_INFO "Read Frame Counter failed!\n");
2365 }
2366 return -1;
2367 }
2368 fc = j->ssr.high << 8 | j->ssr.low;
2369 if (fc == j->frame_count)
2370 return 1;
2371
2372 j->frame_count = fc;
2373
2374 if (j->dtmf_proc)
2375 return 1;
2376
2377 var = 10;
2378
2379 for (cnt = 0; cnt < 4; cnt++) {
2380 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2381 if(ixjdebug & 0x0001) {
2382 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2383 }
2384 return -1;
2385 }
2386 if (ixj_WriteDSPCommand(0x515C, j)) {
2387 if(ixjdebug & 0x0001) {
2388 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2389 }
2390 return -1;
2391 }
2392 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2393
2394 if (j->cadence_f[cnt].enable) {
2395 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2396 if (j->cadence_f[cnt].state == 0) {
2397 j->cadence_f[cnt].state = 1;
2398 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2399 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2400 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2401 } else if (j->cadence_f[cnt].state == 2 &&
2402 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2403 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2404 if (j->cadence_f[cnt].on2) {
2405 j->cadence_f[cnt].state = 3;
2406 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2407 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2408 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2409 } else {
2410 j->cadence_f[cnt].state = 7;
2411 }
2412 } else if (j->cadence_f[cnt].state == 4 &&
2413 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2414 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2415 if (j->cadence_f[cnt].on3) {
2416 j->cadence_f[cnt].state = 5;
2417 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2418 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2419 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2420 } else {
2421 j->cadence_f[cnt].state = 7;
2422 }
2423 } else {
2424 j->cadence_f[cnt].state = 0;
2425 }
2426 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2427 if (j->cadence_f[cnt].state == 1) {
2428 if(!j->cadence_f[cnt].on1) {
2429 j->cadence_f[cnt].state = 7;
2430 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2431 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2432 if(j->cadence_f[cnt].off1) {
2433 j->cadence_f[cnt].state = 2;
2434 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2435 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2436 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2437 } else {
2438 j->cadence_f[cnt].state = 7;
2439 }
2440 } else {
2441 j->cadence_f[cnt].state = 0;
2442 }
2443 } else if (j->cadence_f[cnt].state == 3) {
2444 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2445 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2446 if(j->cadence_f[cnt].off2) {
2447 j->cadence_f[cnt].state = 4;
2448 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2449 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2450 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2451 } else {
2452 j->cadence_f[cnt].state = 7;
2453 }
2454 } else {
2455 j->cadence_f[cnt].state = 0;
2456 }
2457 } else if (j->cadence_f[cnt].state == 5) {
2458 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2459 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2460 if(j->cadence_f[cnt].off3) {
2461 j->cadence_f[cnt].state = 6;
2462 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2463 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2464 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2465 } else {
2466 j->cadence_f[cnt].state = 7;
2467 }
2468 } else {
2469 j->cadence_f[cnt].state = 0;
2470 }
2471 } else {
2472 j->cadence_f[cnt].state = 0;
2473 }
2474 } else {
2475 switch(j->cadence_f[cnt].state) {
2476 case 1:
2477 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2478 !j->cadence_f[cnt].off1 &&
2479 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2480 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2481 j->cadence_f[cnt].state = 7;
2482 }
2483 break;
2484 case 3:
2485 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2486 !j->cadence_f[cnt].off2 &&
2487 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2488 j->cadence_f[cnt].state = 7;
2489 }
2490 break;
2491 case 5:
2492 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2493 !j->cadence_f[cnt].off3) {
2494 j->cadence_f[cnt].state = 7;
2495 }
2496 break;
2497 }
2498 }
2499
2500 if (ixjdebug & 0x0040) {
2501 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2502 switch(j->cadence_f[cnt].state) {
2503 case 0:
2504 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2505 break;
2506 case 1:
2507 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2508 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2509 break;
2510 case 2:
2511 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2512 j->cadence_f[cnt].off1max);
2513 break;
2514 case 3:
2515 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2516 j->cadence_f[cnt].on2max);
2517 break;
2518 case 4:
2519 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2520 j->cadence_f[cnt].off2max);
2521 break;
2522 case 5:
2523 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2524 j->cadence_f[cnt].on3max);
2525 break;
2526 case 6:
2527 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2528 j->cadence_f[cnt].off3max);
2529 break;
2530 }
2531 }
2532 }
2533 if (j->cadence_f[cnt].state == 7) {
2534 j->cadence_f[cnt].state = 0;
2535 if (j->cadence_f[cnt].enable == 1)
2536 j->cadence_f[cnt].enable = 0;
2537 switch (cnt) {
2538 case 0:
2539 if(ixjdebug & 0x0020) {
2540 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2541 }
2542 j->ex.bits.fc0 = 1;
2543 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2544 break;
2545 case 1:
2546 if(ixjdebug & 0x0020) {
2547 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2548 }
2549 j->ex.bits.fc1 = 1;
2550 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2551 break;
2552 case 2:
2553 if(ixjdebug & 0x0020) {
2554 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2555 }
2556 j->ex.bits.fc2 = 1;
2557 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2558 break;
2559 case 3:
2560 if(ixjdebug & 0x0020) {
2561 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2562 }
2563 j->ex.bits.fc3 = 1;
2564 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2565 break;
2566 }
2567 }
2568 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2569 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2570 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2571 trg = 1;
2572 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2573 trg = 0;
2574 }
2575 switch (cnt) {
2576 case 0:
2577 if(ixjdebug & 0x0020) {
2578 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2579 }
2580 j->ex.bits.f0 = 1;
2581 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2582 break;
2583 case 1:
2584 if(ixjdebug & 0x0020) {
2585 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2586 }
2587 j->ex.bits.f1 = 1;
2588 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2589 break;
2590 case 2:
2591 if(ixjdebug & 0x0020) {
2592 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2593 }
2594 j->ex.bits.f2 = 1;
2595 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2596 break;
2597 case 3:
2598 if(ixjdebug & 0x0020) {
2599 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2600 }
2601 j->ex.bits.f3 = 1;
2602 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2603 break;
2604 }
2605 }
2606 }
2607 return 0;
2608 }
2609
2610 static int LineMonitor(IXJ *j)
2611 {
2612 if (j->dtmf_proc) {
2613 return -1;
2614 }
2615 j->dtmf_proc = 1;
2616
2617 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2618 return -1;
2619
2620 j->dtmf.bytes.high = j->ssr.high;
2621 j->dtmf.bytes.low = j->ssr.low;
2622 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2623 j->dtmf_state = 1;
2624 j->dtmf_current = j->dtmf.bits.digit;
2625 }
2626 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2627 {
2628 if(!j->cidcw_wait) {
2629 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2630 j->dtmf_wp++;
2631 if (j->dtmf_wp == 79)
2632 j->dtmf_wp = 0;
2633 j->ex.bits.dtmf_ready = 1;
2634 if(j->ex_sig.bits.dtmf_ready) {
2635 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2636 }
2637 }
2638 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2639 if(ixjdebug & 0x0020) {
2640 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2641 }
2642 j->flags.cidcw_ack = 1;
2643 }
2644 j->dtmf_state = 0;
2645 }
2646 j->dtmf_proc = 0;
2647
2648 return 0;
2649 }
2650
2651 /************************************************************************
2652 *
2653 * Functions to allow alaw <-> ulaw conversions.
2654 *
2655 ************************************************************************/
2656
2657 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2658 {
2659 static unsigned char table_ulaw2alaw[] =
2660 {
2661 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2662 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2663 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2664 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2665 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2666 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2667 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2668 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2669 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2670 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2671 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2672 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2673 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2674 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2675 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2676 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2677 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2678 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2679 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2680 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2681 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2682 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2683 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2684 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2685 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2686 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2687 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2688 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2689 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2690 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2691 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2692 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2693 };
2694
2695 while (len--)
2696 {
2697 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2698 buff++;
2699 }
2700 }
2701
2702 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2703 {
2704 static unsigned char table_alaw2ulaw[] =
2705 {
2706 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2707 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2708 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2709 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2710 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2711 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2712 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2713 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2714 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2715 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2716 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2717 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2718 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2719 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2720 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2721 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2722 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2723 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2724 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2725 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2726 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2727 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2728 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2729 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2730 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2731 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2732 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2733 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2734 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2735 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2736 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2737 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2738 };
2739
2740 while (len--)
2741 {
2742 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2743 buff++;
2744 }
2745 }
2746
2747 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2748 {
2749 unsigned long i = *ppos;
2750 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2751
2752 DECLARE_WAITQUEUE(wait, current);
2753
2754 if (j->flags.inread)
2755 return -EALREADY;
2756
2757 j->flags.inread = 1;
2758
2759 add_wait_queue(&j->read_q, &wait);
2760 set_current_state(TASK_INTERRUPTIBLE);
2761 mb();
2762
2763 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2764 ++j->read_wait;
2765 if (file_p->f_flags & O_NONBLOCK) {
2766 set_current_state(TASK_RUNNING);
2767 remove_wait_queue(&j->read_q, &wait);
2768 j->flags.inread = 0;
2769 return -EAGAIN;
2770 }
2771 if (!ixj_hookstate(j)) {
2772 set_current_state(TASK_RUNNING);
2773 remove_wait_queue(&j->read_q, &wait);
2774 j->flags.inread = 0;
2775 return 0;
2776 }
2777 interruptible_sleep_on(&j->read_q);
2778 if (signal_pending(current)) {
2779 set_current_state(TASK_RUNNING);
2780 remove_wait_queue(&j->read_q, &wait);
2781 j->flags.inread = 0;
2782 return -EINTR;
2783 }
2784 }
2785
2786 remove_wait_queue(&j->read_q, &wait);
2787 set_current_state(TASK_RUNNING);
2788 /* Don't ever copy more than the user asks */
2789 if(j->rec_codec == ALAW)
2790 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2791 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2792 j->read_buffer_ready = 0;
2793 if (i) {
2794 j->flags.inread = 0;
2795 return -EFAULT;
2796 } else {
2797 j->flags.inread = 0;
2798 return min(length, j->read_buffer_size);
2799 }
2800 }
2801
2802 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2803 loff_t * ppos)
2804 {
2805 int pre_retval;
2806 ssize_t read_retval = 0;
2807 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2808
2809 pre_retval = ixj_PreRead(j, 0L);
2810 switch (pre_retval) {
2811 case NORMAL:
2812 read_retval = ixj_read(file_p, buf, length, ppos);
2813 ixj_PostRead(j, 0L);
2814 break;
2815 case NOPOST:
2816 read_retval = ixj_read(file_p, buf, length, ppos);
2817 break;
2818 case POSTONLY:
2819 ixj_PostRead(j, 0L);
2820 break;
2821 default:
2822 read_retval = pre_retval;
2823 }
2824 return read_retval;
2825 }
2826
2827 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2828 {
2829 unsigned long i = *ppos;
2830 IXJ *j = file_p->private_data;
2831
2832 DECLARE_WAITQUEUE(wait, current);
2833
2834 if (j->flags.inwrite)
2835 return -EALREADY;
2836
2837 j->flags.inwrite = 1;
2838
2839 add_wait_queue(&j->write_q, &wait);
2840 set_current_state(TASK_INTERRUPTIBLE);
2841 mb();
2842
2843
2844 while (!j->write_buffers_empty) {
2845 ++j->write_wait;
2846 if (file_p->f_flags & O_NONBLOCK) {
2847 set_current_state(TASK_RUNNING);
2848 remove_wait_queue(&j->write_q, &wait);
2849 j->flags.inwrite = 0;
2850 return -EAGAIN;
2851 }
2852 if (!ixj_hookstate(j)) {
2853 set_current_state(TASK_RUNNING);
2854 remove_wait_queue(&j->write_q, &wait);
2855 j->flags.inwrite = 0;
2856 return 0;
2857 }
2858 interruptible_sleep_on(&j->write_q);
2859 if (signal_pending(current)) {
2860 set_current_state(TASK_RUNNING);
2861 remove_wait_queue(&j->write_q, &wait);
2862 j->flags.inwrite = 0;
2863 return -EINTR;
2864 }
2865 }
2866 set_current_state(TASK_RUNNING);
2867 remove_wait_queue(&j->write_q, &wait);
2868 if (j->write_buffer_wp + count >= j->write_buffer_end)
2869 j->write_buffer_wp = j->write_buffer;
2870 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2871 if (i) {
2872 j->flags.inwrite = 0;
2873 return -EFAULT;
2874 }
2875 if(j->play_codec == ALAW)
2876 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2877 j->flags.inwrite = 0;
2878 return min(count, j->write_buffer_size);
2879 }
2880
2881 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2882 {
2883 int pre_retval;
2884 ssize_t write_retval = 0;
2885
2886 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2887
2888 pre_retval = ixj_PreWrite(j, 0L);
2889 switch (pre_retval) {
2890 case NORMAL:
2891 write_retval = ixj_write(file_p, buf, count, ppos);
2892 if (write_retval > 0) {
2893 ixj_PostWrite(j, 0L);
2894 j->write_buffer_wp += write_retval;
2895 j->write_buffers_empty--;
2896 }
2897 break;
2898 case NOPOST:
2899 write_retval = ixj_write(file_p, buf, count, ppos);
2900 if (write_retval > 0) {
2901 j->write_buffer_wp += write_retval;
2902 j->write_buffers_empty--;
2903 }
2904 break;
2905 case POSTONLY:
2906 ixj_PostWrite(j, 0L);
2907 break;
2908 default:
2909 write_retval = pre_retval;
2910 }
2911 return write_retval;
2912 }
2913
2914 static void ixj_read_frame(IXJ *j)
2915 {
2916 int cnt, dly;
2917
2918 if (j->read_buffer) {
2919 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2920 if (!(cnt % 16) && !IsRxReady(j)) {
2921 dly = 0;
2922 while (!IsRxReady(j)) {
2923 if (dly++ > 5) {
2924 dly = 0;
2925 break;
2926 }
2927 udelay(10);
2928 }
2929 }
2930 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2931 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2932 inb_p(j->DSPbase + 0x0E);
2933 inb_p(j->DSPbase + 0x0F);
2934 }
2935 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2936 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2937 }
2938 ++j->framesread;
2939 if (j->intercom != -1) {
2940 if (IsTxReady(get_ixj(j->intercom))) {
2941 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2942 if (!(cnt % 16) && !IsTxReady(j)) {
2943 dly = 0;
2944 while (!IsTxReady(j)) {
2945 if (dly++ > 5) {
2946 dly = 0;
2947 break;
2948 }
2949 udelay(10);
2950 }
2951 }
2952 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2953 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2954 }
2955 get_ixj(j->intercom)->frameswritten++;
2956 }
2957 } else {
2958 j->read_buffer_ready = 1;
2959 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2960
2961 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2962
2963 if(j->ixj_signals[SIG_READ_READY])
2964 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2965 }
2966 }
2967 }
2968
2969 static short fsk[][6][20] =
2970 {
2971 {
2972 {
2973 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2974 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2975 },
2976 {
2977 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2978 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2979 },
2980 {
2981 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2982 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2983 },
2984 {
2985 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2986 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2987 },
2988 {
2989 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2990 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2991 },
2992 {
2993 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2994 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2995 }
2996 },
2997 {
2998 {
2999 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3000 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3001 },
3002 {
3003 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3004 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3005 },
3006 {
3007 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3008 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3009 },
3010 {
3011 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3012 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3013 },
3014 {
3015 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3016 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3017 },
3018 {
3019 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3020 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3021 }
3022 }
3023 };
3024
3025
3026 static void ixj_write_cid_bit(IXJ *j, int bit)
3027 {
3028 while (j->fskcnt < 20) {
3029 if(j->fskdcnt < (j->fsksize - 1))
3030 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3031
3032 j->fskcnt += 3;
3033 }
3034 j->fskcnt %= 20;
3035
3036 if (!bit)
3037 j->fskz++;
3038 if (j->fskz >= 6)
3039 j->fskz = 0;
3040
3041 }
3042
3043 static void ixj_write_cid_byte(IXJ *j, char byte)
3044 {
3045 IXJ_CBYTE cb;
3046
3047 cb.cbyte = byte;
3048 ixj_write_cid_bit(j, 0);
3049 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3055 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3056 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3057 ixj_write_cid_bit(j, 1);
3058 }
3059
3060 static void ixj_write_cid_seize(IXJ *j)
3061 {
3062 int cnt;
3063
3064 for (cnt = 0; cnt < 150; cnt++) {
3065 ixj_write_cid_bit(j, 0);
3066 ixj_write_cid_bit(j, 1);
3067 }
3068 for (cnt = 0; cnt < 180; cnt++) {
3069 ixj_write_cid_bit(j, 1);
3070 }
3071 }
3072
3073 static void ixj_write_cidcw_seize(IXJ *j)
3074 {
3075 int cnt;
3076
3077 for (cnt = 0; cnt < 80; cnt++) {
3078 ixj_write_cid_bit(j, 1);
3079 }
3080 }
3081
3082 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3083 {
3084 int cnt;
3085
3086 for (cnt = 0; cnt < strlen(s); cnt++) {
3087 ixj_write_cid_byte(j, s[cnt]);
3088 checksum = (checksum + s[cnt]);
3089 }
3090 return checksum;
3091 }
3092
3093 static void ixj_pad_fsk(IXJ *j, int pad)
3094 {
3095 int cnt;
3096
3097 for (cnt = 0; cnt < pad; cnt++) {
3098 if(j->fskdcnt < (j->fsksize - 1))
3099 j->fskdata[j->fskdcnt++] = 0x0000;
3100 }
3101 for (cnt = 0; cnt < 720; cnt++) {
3102 if(j->fskdcnt < (j->fsksize - 1))
3103 j->fskdata[j->fskdcnt++] = 0x0000;
3104 }
3105 }
3106
3107 static void ixj_pre_cid(IXJ *j)
3108 {
3109 j->cid_play_codec = j->play_codec;
3110 j->cid_play_frame_size = j->play_frame_size;
3111 j->cid_play_volume = get_play_volume(j);
3112 j->cid_play_flag = j->flags.playing;
3113
3114 j->cid_rec_codec = j->rec_codec;
3115 j->cid_rec_volume = get_rec_volume(j);
3116 j->cid_rec_flag = j->flags.recording;
3117
3118 j->cid_play_aec_level = j->aec_level;
3119
3120 switch(j->baseframe.low) {
3121 case 0xA0:
3122 j->cid_base_frame_size = 20;
3123 break;
3124 case 0x50:
3125 j->cid_base_frame_size = 10;
3126 break;
3127 case 0xF0:
3128 j->cid_base_frame_size = 30;
3129 break;
3130 }
3131
3132 ixj_play_stop(j);
3133 ixj_cpt_stop(j);
3134
3135 j->flags.cidplay = 1;
3136
3137 set_base_frame(j, 30);
3138 set_play_codec(j, LINEAR16);
3139 set_play_volume(j, 0x1B);
3140 ixj_play_start(j);
3141 }
3142
3143 static void ixj_post_cid(IXJ *j)
3144 {
3145 ixj_play_stop(j);
3146
3147 if(j->cidsize > 5000) {
3148 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3149 }
3150 j->flags.cidplay = 0;
3151 if(ixjdebug & 0x0200) {
3152 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3153 }
3154
3155 ixj_fsk_free(j);
3156
3157 j->fskdcnt = 0;
3158 set_base_frame(j, j->cid_base_frame_size);
3159 set_play_codec(j, j->cid_play_codec);
3160 ixj_aec_start(j, j->cid_play_aec_level);
3161 set_play_volume(j, j->cid_play_volume);
3162
3163 set_rec_codec(j, j->cid_rec_codec);
3164 set_rec_volume(j, j->cid_rec_volume);
3165
3166 if(j->cid_rec_flag)
3167 ixj_record_start(j);
3168
3169 if(j->cid_play_flag)
3170 ixj_play_start(j);
3171
3172 if(j->cid_play_flag) {
3173 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3174 }
3175 }
3176
3177 static void ixj_write_cid(IXJ *j)
3178 {
3179 char sdmf1[50];
3180 char sdmf2[50];
3181 char sdmf3[80];
3182 char mdmflen, len1, len2, len3;
3183 int pad;
3184
3185 int checksum = 0;
3186
3187 if (j->dsp.low == 0x20 || j->flags.cidplay)
3188 return;
3189
3190 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3191 j->cidsize = j->cidcnt = 0;
3192
3193 ixj_fsk_alloc(j);
3194
3195 strcpy(sdmf1, j->cid_send.month);
3196 strcat(sdmf1, j->cid_send.day);
3197 strcat(sdmf1, j->cid_send.hour);
3198 strcat(sdmf1, j->cid_send.min);
3199 strcpy(sdmf2, j->cid_send.number);
3200 strcpy(sdmf3, j->cid_send.name);
3201
3202 len1 = strlen(sdmf1);
3203 len2 = strlen(sdmf2);
3204 len3 = strlen(sdmf3);
3205 mdmflen = len1 + len2 + len3 + 6;
3206
3207 while(1){
3208 ixj_write_cid_seize(j);
3209
3210 ixj_write_cid_byte(j, 0x80);
3211 checksum = 0x80;
3212 ixj_write_cid_byte(j, mdmflen);
3213 checksum = checksum + mdmflen;
3214
3215 ixj_write_cid_byte(j, 0x01);
3216 checksum = checksum + 0x01;
3217 ixj_write_cid_byte(j, len1);
3218 checksum = checksum + len1;
3219 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3220 if(ixj_hookstate(j) & 1)
3221 break;
3222
3223 ixj_write_cid_byte(j, 0x02);
3224 checksum = checksum + 0x02;
3225 ixj_write_cid_byte(j, len2);
3226 checksum = checksum + len2;
3227 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3228 if(ixj_hookstate(j) & 1)
3229 break;
3230
3231 ixj_write_cid_byte(j, 0x07);
3232 checksum = checksum + 0x07;
3233 ixj_write_cid_byte(j, len3);
3234 checksum = checksum + len3;
3235 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3236 if(ixj_hookstate(j) & 1)
3237 break;
3238
3239 checksum %= 256;
3240 checksum ^= 0xFF;
3241 checksum += 1;
3242
3243 ixj_write_cid_byte(j, (char) checksum);
3244
3245 pad = j->fskdcnt % 240;
3246 if (pad) {
3247 pad = 240 - pad;
3248 }
3249 ixj_pad_fsk(j, pad);
3250 break;
3251 }
3252
3253 ixj_write_frame(j);
3254 }
3255
3256 static void ixj_write_cidcw(IXJ *j)
3257 {
3258 IXJ_TONE ti;
3259
3260 char sdmf1[50];
3261 char sdmf2[50];
3262 char sdmf3[80];
3263 char mdmflen, len1, len2, len3;
3264 int pad;
3265
3266 int checksum = 0;
3267
3268 if (j->dsp.low == 0x20 || j->flags.cidplay)
3269 return;
3270
3271 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3272 j->cidsize = j->cidcnt = 0;
3273
3274 ixj_fsk_alloc(j);
3275
3276 j->flags.cidcw_ack = 0;
3277
3278 ti.tone_index = 23;
3279 ti.gain0 = 1;
3280 ti.freq0 = hz440;
3281 ti.gain1 = 0;
3282 ti.freq1 = 0;
3283 ixj_init_tone(j, &ti);
3284
3285 ixj_set_tone_on(1500, j);
3286 ixj_set_tone_off(32, j);
3287 if(ixjdebug & 0x0200) {
3288 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3289 }
3290 ixj_play_tone(j, 23);
3291
3292 clear_bit(j->board, &j->busyflags);
3293 while(j->tone_state)
3294 schedule_timeout_interruptible(1);
3295 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3296 schedule_timeout_interruptible(1);
3297 if(ixjdebug & 0x0200) {
3298 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3299 }
3300
3301 ti.tone_index = 24;
3302 ti.gain0 = 1;
3303 ti.freq0 = hz2130;
3304 ti.gain1 = 0;
3305 ti.freq1 = hz2750;
3306 ixj_init_tone(j, &ti);
3307
3308 ixj_set_tone_off(10, j);
3309 ixj_set_tone_on(600, j);
3310 if(ixjdebug & 0x0200) {
3311 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3312 }
3313 ixj_play_tone(j, 24);
3314
3315 clear_bit(j->board, &j->busyflags);
3316 while(j->tone_state)
3317 schedule_timeout_interruptible(1);
3318 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3319 schedule_timeout_interruptible(1);
3320 if(ixjdebug & 0x0200) {
3321 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3322 }
3323
3324 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3325
3326 clear_bit(j->board, &j->busyflags);
3327 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3328 schedule_timeout_interruptible(1);
3329 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3330 schedule_timeout_interruptible(1);
3331 j->cidcw_wait = 0;
3332 if(!j->flags.cidcw_ack) {
3333 if(ixjdebug & 0x0200) {
3334 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3335 }
3336 ixj_post_cid(j);
3337 if(j->cid_play_flag) {
3338 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3339 }
3340 return;
3341 } else {
3342 ixj_pre_cid(j);
3343 }
3344 j->flags.cidcw_ack = 0;
3345 strcpy(sdmf1, j->cid_send.month);
3346 strcat(sdmf1, j->cid_send.day);
3347 strcat(sdmf1, j->cid_send.hour);
3348 strcat(sdmf1, j->cid_send.min);
3349 strcpy(sdmf2, j->cid_send.number);
3350 strcpy(sdmf3, j->cid_send.name);
3351
3352 len1 = strlen(sdmf1);
3353 len2 = strlen(sdmf2);
3354 len3 = strlen(sdmf3);
3355 mdmflen = len1 + len2 + len3 + 6;
3356
3357 ixj_write_cidcw_seize(j);
3358
3359 ixj_write_cid_byte(j, 0x80);
3360 checksum = 0x80;
3361 ixj_write_cid_byte(j, mdmflen);
3362 checksum = checksum + mdmflen;
3363
3364 ixj_write_cid_byte(j, 0x01);
3365 checksum = checksum + 0x01;
3366 ixj_write_cid_byte(j, len1);
3367 checksum = checksum + len1;
3368 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3369
3370 ixj_write_cid_byte(j, 0x02);
3371 checksum = checksum + 0x02;
3372 ixj_write_cid_byte(j, len2);
3373 checksum = checksum + len2;
3374 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3375
3376 ixj_write_cid_byte(j, 0x07);
3377 checksum = checksum + 0x07;
3378 ixj_write_cid_byte(j, len3);
3379 checksum = checksum + len3;
3380 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3381
3382 checksum %= 256;
3383 checksum ^= 0xFF;
3384 checksum += 1;
3385
3386 ixj_write_cid_byte(j, (char) checksum);
3387
3388 pad = j->fskdcnt % 240;
3389 if (pad) {
3390 pad = 240 - pad;
3391 }
3392 ixj_pad_fsk(j, pad);
3393 if(ixjdebug & 0x0200) {
3394 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3395 }
3396 }
3397
3398 static void ixj_write_vmwi(IXJ *j, int msg)
3399 {
3400 char mdmflen;
3401 int pad;
3402
3403 int checksum = 0;
3404
3405 if (j->dsp.low == 0x20 || j->flags.cidplay)
3406 return;
3407
3408 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3409 j->cidsize = j->cidcnt = 0;
3410
3411 ixj_fsk_alloc(j);
3412
3413 mdmflen = 3;
3414
3415 if (j->port == PORT_POTS)
3416 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3417
3418 ixj_write_cid_seize(j);
3419
3420 ixj_write_cid_byte(j, 0x82);
3421 checksum = 0x82;
3422 ixj_write_cid_byte(j, mdmflen);
3423 checksum = checksum + mdmflen;
3424
3425 ixj_write_cid_byte(j, 0x0B);
3426 checksum = checksum + 0x0B;
3427 ixj_write_cid_byte(j, 1);
3428 checksum = checksum + 1;
3429
3430 if(msg) {
3431 ixj_write_cid_byte(j, 0xFF);
3432 checksum = checksum + 0xFF;
3433 }
3434 else {
3435 ixj_write_cid_byte(j, 0x00);
3436 checksum = checksum + 0x00;
3437 }
3438
3439 checksum %= 256;
3440 checksum ^= 0xFF;
3441 checksum += 1;
3442
3443 ixj_write_cid_byte(j, (char) checksum);
3444
3445 pad = j->fskdcnt % 240;
3446 if (pad) {
3447 pad = 240 - pad;
3448 }
3449 ixj_pad_fsk(j, pad);
3450 }
3451
3452 static void ixj_write_frame(IXJ *j)
3453 {
3454 int cnt, frame_count, dly;
3455 IXJ_WORD dat;
3456 BYTES blankword;
3457
3458 frame_count = 0;
3459 if(j->flags.cidplay) {
3460 for(cnt = 0; cnt < 480; cnt++) {
3461 if (!(cnt % 16) && !IsTxReady(j)) {
3462 dly = 0;
3463 while (!IsTxReady(j)) {
3464 if (dly++ > 5) {
3465 dly = 0;
3466 break;
3467 }
3468 udelay(10);
3469 }
3470 }
3471 dat.word = j->fskdata[j->cidcnt++];
3472 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3473 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3474 cnt++;
3475 }
3476 if(j->cidcnt >= j->fskdcnt) {
3477 ixj_post_cid(j);
3478 }
3479 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3480 and there is real audio data in the buffer, we need to throw it away because
3481 we just used it's time slot */
3482 if (j->write_buffer_rp > j->write_buffer_wp) {
3483 j->write_buffer_rp += j->cid_play_frame_size * 2;
3484 if (j->write_buffer_rp >= j->write_buffer_end) {
3485 j->write_buffer_rp = j->write_buffer;
3486 }
3487 j->write_buffers_empty++;
3488 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3489
3490 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3491 }
3492 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3493 if (j->write_buffer_wp > j->write_buffer_rp) {
3494 frame_count =
3495 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3496 }
3497 if (j->write_buffer_rp > j->write_buffer_wp) {
3498 frame_count =
3499 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3500 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3501 }
3502 if (frame_count >= 1) {
3503 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3504 switch (j->play_mode) {
3505 case PLAYBACK_MODE_ULAW:
3506 case PLAYBACK_MODE_ALAW:
3507 blankword.low = blankword.high = 0xFF;
3508 break;
3509 case PLAYBACK_MODE_8LINEAR:
3510 case PLAYBACK_MODE_16LINEAR:
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 if(cnt == 12) {
3535 blankword.low = 0x02;
3536 blankword.high = 0x00;
3537 }
3538 else {
3539 blankword.low = blankword.high = 0x00;
3540 }
3541 if (!(cnt % 16) && !IsTxReady(j)) {
3542 dly = 0;
3543 while (!IsTxReady(j)) {
3544 if (dly++ > 5) {
3545 dly = 0;
3546 break;
3547 }
3548 udelay(10);
3549 }
3550 }
3551 outb_p((blankword.low), j->DSPbase + 0x0C);
3552 outb_p((blankword.high), j->DSPbase + 0x0D);
3553 }
3554 j->flags.play_first_frame = 0;
3555 }
3556 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3557 if (!(cnt % 16) && !IsTxReady(j)) {
3558 dly = 0;
3559 while (!IsTxReady(j)) {
3560 if (dly++ > 5) {
3561 dly = 0;
3562 break;
3563 }
3564 udelay(10);
3565 }
3566 }
3567 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3568 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3569 if (j->write_buffer_rp[cnt] == 0 &&
3570 j->write_buffer_rp[cnt + 1] == 0 &&
3571 j->write_buffer_rp[cnt + 2] == 0 &&
3572 j->write_buffer_rp[cnt + 3] == 0 &&
3573 j->write_buffer_rp[cnt + 4] == 0 &&
3574 j->write_buffer_rp[cnt + 5] == 0 &&
3575 j->write_buffer_rp[cnt + 6] == 0 &&
3576 j->write_buffer_rp[cnt + 7] == 0 &&
3577 j->write_buffer_rp[cnt + 8] == 0 &&
3578 j->write_buffer_rp[cnt + 9] == 0) {
3579 /* someone is trying to write silence lets make this a type 0 frame. */
3580 outb_p(0x00, j->DSPbase + 0x0C);
3581 outb_p(0x00, j->DSPbase + 0x0D);
3582 } else {
3583 /* so all other frames are type 1. */
3584 outb_p(0x01, j->DSPbase + 0x0C);
3585 outb_p(0x00, j->DSPbase + 0x0D);
3586 }
3587 }
3588 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3589 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3590 *(j->write_buffer_rp + cnt) = 0;
3591 *(j->write_buffer_rp + cnt + 1) = 0;
3592 }
3593 j->write_buffer_rp += j->play_frame_size * 2;
3594 if (j->write_buffer_rp >= j->write_buffer_end) {
3595 j->write_buffer_rp = j->write_buffer;
3596 }
3597 j->write_buffers_empty++;
3598 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3599
3600 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3601
3602 ++j->frameswritten;
3603 }
3604 } else {
3605 j->drybuffer++;
3606 }
3607 if(j->ixj_signals[SIG_WRITE_READY]) {
3608 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3609 }
3610 }
3611
3612 static int idle(IXJ *j)
3613 {
3614 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3615
3616 return 0;
3617
3618 if (j->ssr.high || j->ssr.low) {
3619 return 0;
3620 } else {
3621 j->play_mode = -1;
3622 j->flags.playing = 0;
3623 j->rec_mode = -1;
3624 j->flags.recording = 0;
3625 return 1;
3626 }
3627 }
3628
3629 static int set_base_frame(IXJ *j, int size)
3630 {
3631 unsigned short cmd;
3632 int cnt;
3633
3634 idle(j);
3635 j->cid_play_aec_level = j->aec_level;
3636 aec_stop(j);
3637 for (cnt = 0; cnt < 10; cnt++) {
3638 if (idle(j))
3639 break;
3640 }
3641 if (j->ssr.high || j->ssr.low)
3642 return -1;
3643 if (j->dsp.low != 0x20) {
3644 switch (size) {
3645 case 30:
3646 cmd = 0x07F0;
3647 /* Set Base Frame Size to 240 pg9-10 8021 */
3648 break;
3649 case 20:
3650 cmd = 0x07A0;
3651 /* Set Base Frame Size to 160 pg9-10 8021 */
3652 break;
3653 case 10:
3654 cmd = 0x0750;
3655 /* Set Base Frame Size to 80 pg9-10 8021 */
3656 break;
3657 default:
3658 return -1;
3659 }
3660 } else {
3661 if (size == 30)
3662 return size;
3663 else
3664 return -1;
3665 }
3666 if (ixj_WriteDSPCommand(cmd, j)) {
3667 j->baseframe.high = j->baseframe.low = 0xFF;
3668 return -1;
3669 } else {
3670 j->baseframe.high = j->ssr.high;
3671 j->baseframe.low = j->ssr.low;
3672 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3673 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3674 return -1;
3675 }
3676 }
3677 ixj_aec_start(j, j->cid_play_aec_level);
3678 return size;
3679 }
3680
3681 static int set_rec_codec(IXJ *j, int rate)
3682 {
3683 int retval = 0;
3684
3685 j->rec_codec = rate;
3686
3687 switch (rate) {
3688 case G723_63:
3689 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3690 j->rec_frame_size = 12;
3691 j->rec_mode = 0;
3692 } else {
3693 retval = 1;
3694 }
3695 break;
3696 case G723_53:
3697 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3698 j->rec_frame_size = 10;
3699 j->rec_mode = 0;
3700 } else {
3701 retval = 1;
3702 }
3703 break;
3704 case TS85:
3705 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3706 j->rec_frame_size = 16;
3707 j->rec_mode = 0;
3708 } else {
3709 retval = 1;
3710 }
3711 break;
3712 case TS48:
3713 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3714 j->rec_frame_size = 9;
3715 j->rec_mode = 0;
3716 } else {
3717 retval = 1;
3718 }
3719 break;
3720 case TS41:
3721 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3722 j->rec_frame_size = 8;
3723 j->rec_mode = 0;
3724 } else {
3725 retval = 1;
3726 }
3727 break;
3728 case G728:
3729 if (j->dsp.low != 0x20) {
3730 j->rec_frame_size = 48;
3731 j->rec_mode = 0;
3732 } else {
3733 retval = 1;
3734 }
3735 break;
3736 case G729:
3737 if (j->dsp.low != 0x20) {
3738 if (!j->flags.g729_loaded) {
3739 retval = 1;
3740 break;
3741 }
3742 switch (j->baseframe.low) {
3743 case 0xA0:
3744 j->rec_frame_size = 10;
3745 break;
3746 case 0x50:
3747 j->rec_frame_size = 5;
3748 break;
3749 default:
3750 j->rec_frame_size = 15;
3751 break;
3752 }
3753 j->rec_mode = 0;
3754 } else {
3755 retval = 1;
3756 }
3757 break;
3758 case G729B:
3759 if (j->dsp.low != 0x20) {
3760 if (!j->flags.g729_loaded) {
3761 retval = 1;
3762 break;
3763 }
3764 switch (j->baseframe.low) {
3765 case 0xA0:
3766 j->rec_frame_size = 12;
3767 break;
3768 case 0x50:
3769 j->rec_frame_size = 6;
3770 break;
3771 default:
3772 j->rec_frame_size = 18;
3773 break;
3774 }
3775 j->rec_mode = 0;
3776 } else {
3777 retval = 1;
3778 }
3779 break;
3780 case ULAW:
3781 switch (j->baseframe.low) {
3782 case 0xA0:
3783 j->rec_frame_size = 80;
3784 break;
3785 case 0x50:
3786 j->rec_frame_size = 40;
3787 break;
3788 default:
3789 j->rec_frame_size = 120;
3790 break;
3791 }
3792 j->rec_mode = 4;
3793 break;
3794 case ALAW:
3795 switch (j->baseframe.low) {
3796 case 0xA0:
3797 j->rec_frame_size = 80;
3798 break;
3799 case 0x50:
3800 j->rec_frame_size = 40;
3801 break;
3802 default:
3803 j->rec_frame_size = 120;
3804 break;
3805 }
3806 j->rec_mode = 4;
3807 break;
3808 case LINEAR16:
3809 switch (j->baseframe.low) {
3810 case 0xA0:
3811 j->rec_frame_size = 160;
3812 break;
3813 case 0x50:
3814 j->rec_frame_size = 80;
3815 break;
3816 default:
3817 j->rec_frame_size = 240;
3818 break;
3819 }
3820 j->rec_mode = 5;
3821 break;
3822 case LINEAR8:
3823 switch (j->baseframe.low) {
3824 case 0xA0:
3825 j->rec_frame_size = 80;
3826 break;
3827 case 0x50:
3828 j->rec_frame_size = 40;
3829 break;
3830 default:
3831 j->rec_frame_size = 120;
3832 break;
3833 }
3834 j->rec_mode = 6;
3835 break;
3836 case WSS:
3837 switch (j->baseframe.low) {
3838 case 0xA0:
3839 j->rec_frame_size = 80;
3840 break;
3841 case 0x50:
3842 j->rec_frame_size = 40;
3843 break;
3844 default:
3845 j->rec_frame_size = 120;
3846 break;
3847 }
3848 j->rec_mode = 7;
3849 break;
3850 default:
3851 kfree(j->read_buffer);
3852 j->rec_frame_size = 0;
3853 j->rec_mode = -1;
3854 j->read_buffer = NULL;
3855 j->read_buffer_size = 0;
3856 retval = 1;
3857 break;
3858 }
3859 return retval;
3860 }
3861
3862 static int ixj_record_start(IXJ *j)
3863 {
3864 unsigned short cmd = 0x0000;
3865
3866 if (j->read_buffer) {
3867 ixj_record_stop(j);
3868 }
3869 j->flags.recording = 1;
3870 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3871
3872 if(ixjdebug & 0x0002)
3873 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3874
3875 if (!j->rec_mode) {
3876 switch (j->rec_codec) {
3877 case G723_63:
3878 cmd = 0x5131;
3879 break;
3880 case G723_53:
3881 cmd = 0x5132;
3882 break;
3883 case TS85:
3884 cmd = 0x5130; /* TrueSpeech 8.5 */
3885
3886 break;
3887 case TS48:
3888 cmd = 0x5133; /* TrueSpeech 4.8 */
3889
3890 break;
3891 case TS41:
3892 cmd = 0x5134; /* TrueSpeech 4.1 */
3893
3894 break;
3895 case G728:
3896 cmd = 0x5135;
3897 break;
3898 case G729:
3899 case G729B:
3900 cmd = 0x5136;
3901 break;
3902 default:
3903 return 1;
3904 }
3905 if (ixj_WriteDSPCommand(cmd, j))
3906 return -1;
3907 }
3908 if (!j->read_buffer) {
3909 if (!j->read_buffer)
3910 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3911 if (!j->read_buffer) {
3912 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3913 return -ENOMEM;
3914 }
3915 }
3916 j->read_buffer_size = j->rec_frame_size * 2;
3917
3918 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3919
3920 return -1;
3921
3922 switch (j->rec_mode) {
3923 case 0:
3924 cmd = 0x1C03; /* Record C1 */
3925
3926 break;
3927 case 4:
3928 if (j->ver.low == 0x12) {
3929 cmd = 0x1E03; /* Record C1 */
3930
3931 } else {
3932 cmd = 0x1E01; /* Record C1 */
3933
3934 }
3935 break;
3936 case 5:
3937 if (j->ver.low == 0x12) {
3938 cmd = 0x1E83; /* Record C1 */
3939
3940 } else {
3941 cmd = 0x1E81; /* Record C1 */
3942
3943 }
3944 break;
3945 case 6:
3946 if (j->ver.low == 0x12) {
3947 cmd = 0x1F03; /* Record C1 */
3948
3949 } else {
3950 cmd = 0x1F01; /* Record C1 */
3951
3952 }
3953 break;
3954 case 7:
3955 if (j->ver.low == 0x12) {
3956 cmd = 0x1F83; /* Record C1 */
3957 } else {
3958 cmd = 0x1F81; /* Record C1 */
3959 }
3960 break;
3961 }
3962 if (ixj_WriteDSPCommand(cmd, j))
3963 return -1;
3964
3965 if (j->flags.playing) {
3966 ixj_aec_start(j, j->aec_level);
3967 }
3968 return 0;
3969 }
3970
3971 static void ixj_record_stop(IXJ *j)
3972 {
3973 if (ixjdebug & 0x0002)
3974 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3975
3976 kfree(j->read_buffer);
3977 j->read_buffer = NULL;
3978 j->read_buffer_size = 0;
3979 if (j->rec_mode > -1) {
3980 ixj_WriteDSPCommand(0x5120, j);
3981 j->rec_mode = -1;
3982 }
3983 j->flags.recording = 0;
3984 }
3985 static void ixj_vad(IXJ *j, int arg)
3986 {
3987 if (arg)
3988 ixj_WriteDSPCommand(0x513F, j);
3989 else
3990 ixj_WriteDSPCommand(0x513E, j);
3991 }
3992
3993 static void set_rec_depth(IXJ *j, int depth)
3994 {
3995 if (depth > 60)
3996 depth = 60;
3997 if (depth < 0)
3998 depth = 0;
3999 ixj_WriteDSPCommand(0x5180 + depth, j);
4000 }
4001
4002 static void set_dtmf_prescale(IXJ *j, int volume)
4003 {
4004 ixj_WriteDSPCommand(0xCF07, j);
4005 ixj_WriteDSPCommand(volume, j);
4006 }
4007
4008 static int get_dtmf_prescale(IXJ *j)
4009 {
4010 ixj_WriteDSPCommand(0xCF05, j);
4011 return j->ssr.high << 8 | j->ssr.low;
4012 }
4013
4014 static void set_rec_volume(IXJ *j, int volume)
4015 {
4016 if(j->aec_level == AEC_AGC) {
4017 if (ixjdebug & 0x0002)
4018 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4019 ixj_WriteDSPCommand(0xCF96, j);
4020 ixj_WriteDSPCommand(volume, j);
4021 } else {
4022 if (ixjdebug & 0x0002)
4023 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4024 ixj_WriteDSPCommand(0xCF03, j);
4025 ixj_WriteDSPCommand(volume, j);
4026 }
4027 }
4028
4029 static int set_rec_volume_linear(IXJ *j, int volume)
4030 {
4031 int newvolume, dsprecmax;
4032
4033 if (ixjdebug & 0x0002)
4034 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4035 if(volume > 100 || volume < 0) {
4036 return -1;
4037 }
4038
4039 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4040 switch (j->cardtype) {
4041 case QTI_PHONEJACK:
4042 dsprecmax = 0x440;
4043 break;
4044 case QTI_LINEJACK:
4045 dsprecmax = 0x180;
4046 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4047 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4048 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4049 break;
4050 case QTI_PHONEJACK_LITE:
4051 dsprecmax = 0x4C0;
4052 break;
4053 case QTI_PHONEJACK_PCI:
4054 dsprecmax = 0x100;
4055 break;
4056 case QTI_PHONECARD:
4057 dsprecmax = 0x400;
4058 break;
4059 default:
4060 return -1;
4061 }
4062 newvolume = (dsprecmax * volume) / 100;
4063 set_rec_volume(j, newvolume);
4064 return 0;
4065 }
4066
4067 static int get_rec_volume(IXJ *j)
4068 {
4069 if(j->aec_level == AEC_AGC) {
4070 if (ixjdebug & 0x0002)
4071 printk(KERN_INFO "Getting AGC Threshold\n");
4072 ixj_WriteDSPCommand(0xCF86, j);
4073 if (ixjdebug & 0x0002)
4074 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4075 return j->ssr.high << 8 | j->ssr.low;
4076 } else {
4077 if (ixjdebug & 0x0002)
4078 printk(KERN_INFO "Getting Record Volume\n");
4079 ixj_WriteDSPCommand(0xCF01, j);
4080 return j->ssr.high << 8 | j->ssr.low;
4081 }
4082 }
4083
4084 static int get_rec_volume_linear(IXJ *j)
4085 {
4086 int volume, newvolume, dsprecmax;
4087
4088 switch (j->cardtype) {
4089 case QTI_PHONEJACK:
4090 dsprecmax = 0x440;
4091 break;
4092 case QTI_LINEJACK:
4093 dsprecmax = 0x180;
4094 break;
4095 case QTI_PHONEJACK_LITE:
4096 dsprecmax = 0x4C0;
4097 break;
4098 case QTI_PHONEJACK_PCI:
4099 dsprecmax = 0x100;
4100 break;
4101 case QTI_PHONECARD:
4102 dsprecmax = 0x400;
4103 break;
4104 default:
4105 return -1;
4106 }
4107 volume = get_rec_volume(j);
4108 newvolume = (volume * 100) / dsprecmax;
4109 if(newvolume > 100)
4110 newvolume = 100;
4111 return newvolume;
4112 }
4113
4114 static int get_rec_level(IXJ *j)
4115 {
4116 int retval;
4117
4118 ixj_WriteDSPCommand(0xCF88, j);
4119
4120 retval = j->ssr.high << 8 | j->ssr.low;
4121 retval = (retval * 256) / 240;
4122 return retval;
4123 }
4124
4125 static void ixj_aec_start(IXJ *j, int level)
4126 {
4127 j->aec_level = level;
4128 if (ixjdebug & 0x0002)
4129 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4130 if (!level) {
4131 aec_stop(j);
4132 } else {
4133 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4134 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4135
4136 ixj_WriteDSPCommand(0x0300, j);
4137 }
4138 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4139
4140 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4141
4142 switch (level) {
4143 case AEC_LOW:
4144 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4145
4146 ixj_WriteDSPCommand(0xE011, j);
4147 ixj_WriteDSPCommand(0xFFFF, j);
4148
4149 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4150 ixj_WriteDSPCommand(0x0000, j); /* to off */
4151
4152 break;
4153
4154 case AEC_MED:
4155 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4156
4157 ixj_WriteDSPCommand(0xE011, j);
4158 ixj_WriteDSPCommand(0x0080, j);
4159
4160 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4161 ixj_WriteDSPCommand(0x0000, j); /* to off */
4162
4163 break;
4164
4165 case AEC_HIGH:
4166 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4167
4168 ixj_WriteDSPCommand(0xE011, j);
4169 ixj_WriteDSPCommand(0x0080, j);
4170
4171 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4172 ixj_WriteDSPCommand(0x0000, j); /* to off */
4173
4174 break;
4175
4176 case AEC_AGC:
4177 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4178 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4179
4180 ixj_WriteDSPCommand(0xE011, j);
4181 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4182
4183 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4184
4185 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4186 ixj_WriteDSPCommand(0x0224, j);
4187 else
4188 ixj_WriteDSPCommand(0x1224, j);
4189
4190 ixj_WriteDSPCommand(0xE014, j);
4191 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4192
4193 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4194
4195 /* Now we can set the AGC initial parameters and turn it on */
4196 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4197 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4198
4199 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4200 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4201
4202 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4203 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4204
4205 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4206 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4207
4208 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4209 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4210
4211 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4212 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4213
4214 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4215 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4216
4217 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4218 ixj_WriteDSPCommand(0x0001, j); /* to on */
4219
4220 break;
4221
4222 case AEC_AUTO:
4223 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4224
4225 ixj_WriteDSPCommand(0xE011, j);
4226 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4227
4228 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4229
4230 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4231 ixj_WriteDSPCommand(0x0224, j);
4232 else
4233 ixj_WriteDSPCommand(0x1224, j);
4234
4235 ixj_WriteDSPCommand(0xE014, j);
4236 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4237
4238 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4239
4240 break;
4241 }
4242 }
4243 }
4244
4245 static void aec_stop(IXJ *j)
4246 {
4247 j->aec_level = AEC_OFF;
4248 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4249 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4250
4251 ixj_WriteDSPCommand(0x0700, j);
4252 }
4253 if (j->play_mode != -1 && j->rec_mode != -1)
4254 {
4255 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4256 }
4257 }
4258
4259 static int set_play_codec(IXJ *j, int rate)
4260 {
4261 int retval = 0;
4262
4263 j->play_codec = rate;
4264
4265 switch (rate) {
4266 case G723_63:
4267 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4268 j->play_frame_size = 12;
4269 j->play_mode = 0;
4270 } else {
4271 retval = 1;
4272 }
4273 break;
4274 case G723_53:
4275 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4276 j->play_frame_size = 10;
4277 j->play_mode = 0;
4278 } else {
4279 retval = 1;
4280 }
4281 break;
4282 case TS85:
4283 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4284 j->play_frame_size = 16;
4285 j->play_mode = 0;
4286 } else {
4287 retval = 1;
4288 }
4289 break;
4290 case TS48:
4291 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4292 j->play_frame_size = 9;
4293 j->play_mode = 0;
4294 } else {
4295 retval = 1;
4296 }
4297 break;
4298 case TS41:
4299 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4300 j->play_frame_size = 8;
4301 j->play_mode = 0;
4302 } else {
4303 retval = 1;
4304 }
4305 break;
4306 case G728:
4307 if (j->dsp.low != 0x20) {
4308 j->play_frame_size = 48;
4309 j->play_mode = 0;
4310 } else {
4311 retval = 1;
4312 }
4313 break;
4314 case G729:
4315 if (j->dsp.low != 0x20) {
4316 if (!j->flags.g729_loaded) {
4317 retval = 1;
4318 break;
4319 }
4320 switch (j->baseframe.low) {
4321 case 0xA0:
4322 j->play_frame_size = 10;
4323 break;
4324 case 0x50:
4325 j->play_frame_size = 5;
4326 break;
4327 default:
4328 j->play_frame_size = 15;
4329 break;
4330 }
4331 j->play_mode = 0;
4332 } else {
4333 retval = 1;
4334 }
4335 break;
4336 case G729B:
4337 if (j->dsp.low != 0x20) {
4338 if (!j->flags.g729_loaded) {
4339 retval = 1;
4340 break;
4341 }
4342 switch (j->baseframe.low) {
4343 case 0xA0:
4344 j->play_frame_size = 12;
4345 break;
4346 case 0x50:
4347 j->play_frame_size = 6;
4348 break;
4349 default:
4350 j->play_frame_size = 18;
4351 break;
4352 }
4353 j->play_mode = 0;
4354 } else {
4355 retval = 1;
4356 }
4357 break;
4358 case ULAW:
4359 switch (j->baseframe.low) {
4360 case 0xA0:
4361 j->play_frame_size = 80;
4362 break;
4363 case 0x50:
4364 j->play_frame_size = 40;
4365 break;
4366 default:
4367 j->play_frame_size = 120;
4368 break;
4369 }
4370 j->play_mode = 2;
4371 break;
4372 case ALAW:
4373 switch (j->baseframe.low) {
4374 case 0xA0:
4375 j->play_frame_size = 80;
4376 break;
4377 case 0x50:
4378 j->play_frame_size = 40;
4379 break;
4380 default:
4381 j->play_frame_size = 120;
4382 break;
4383 }
4384 j->play_mode = 2;
4385 break;
4386 case LINEAR16:
4387 switch (j->baseframe.low) {
4388 case 0xA0:
4389 j->play_frame_size = 160;
4390 break;
4391 case 0x50:
4392 j->play_frame_size = 80;
4393 break;
4394 default:
4395 j->play_frame_size = 240;
4396 break;
4397 }
4398 j->play_mode = 6;
4399 break;
4400 case LINEAR8:
4401 switch (j->baseframe.low) {
4402 case 0xA0:
4403 j->play_frame_size = 80;
4404 break;
4405 case 0x50:
4406 j->play_frame_size = 40;
4407 break;
4408 default:
4409 j->play_frame_size = 120;
4410 break;
4411 }
4412 j->play_mode = 4;
4413 break;
4414 case WSS:
4415 switch (j->baseframe.low) {
4416 case 0xA0:
4417 j->play_frame_size = 80;
4418 break;
4419 case 0x50:
4420 j->play_frame_size = 40;
4421 break;
4422 default:
4423 j->play_frame_size = 120;
4424 break;
4425 }
4426 j->play_mode = 5;
4427 break;
4428 default:
4429 kfree(j->write_buffer);
4430 j->play_frame_size = 0;
4431 j->play_mode = -1;
4432 j->write_buffer = NULL;
4433 j->write_buffer_size = 0;
4434 retval = 1;
4435 break;
4436 }
4437 return retval;
4438 }
4439
4440 static int ixj_play_start(IXJ *j)
4441 {
4442 unsigned short cmd = 0x0000;
4443
4444 if (j->write_buffer) {
4445 ixj_play_stop(j);
4446 }
4447
4448 if(ixjdebug & 0x0002)
4449 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4450
4451 j->flags.playing = 1;
4452 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4453
4454 j->flags.play_first_frame = 1;
4455 j->drybuffer = 0;
4456
4457 if (!j->play_mode) {
4458 switch (j->play_codec) {
4459 case G723_63:
4460 cmd = 0x5231;
4461 break;
4462 case G723_53:
4463 cmd = 0x5232;
4464 break;
4465 case TS85:
4466 cmd = 0x5230; /* TrueSpeech 8.5 */
4467
4468 break;
4469 case TS48:
4470 cmd = 0x5233; /* TrueSpeech 4.8 */
4471
4472 break;
4473 case TS41:
4474 cmd = 0x5234; /* TrueSpeech 4.1 */
4475
4476 break;
4477 case G728:
4478 cmd = 0x5235;
4479 break;
4480 case G729:
4481 case G729B:
4482 cmd = 0x5236;
4483 break;
4484 default:
4485 return 1;
4486 }
4487 if (ixj_WriteDSPCommand(cmd, j))
4488 return -1;
4489 }
4490 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4491 if (!j->write_buffer) {
4492 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4493 return -ENOMEM;
4494 }
4495 /* j->write_buffers_empty = 2; */
4496 j->write_buffers_empty = 1;
4497 j->write_buffer_size = j->play_frame_size * 2;
4498 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4499 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4500
4501 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4502
4503 return -1;
4504
4505 switch (j->play_mode) {
4506 case 0:
4507 cmd = 0x2C03;
4508 break;
4509 case 2:
4510 if (j->ver.low == 0x12) {
4511 cmd = 0x2C23;
4512 } else {
4513 cmd = 0x2C21;
4514 }
4515 break;
4516 case 4:
4517 if (j->ver.low == 0x12) {
4518 cmd = 0x2C43;
4519 } else {
4520 cmd = 0x2C41;
4521 }
4522 break;
4523 case 5:
4524 if (j->ver.low == 0x12) {
4525 cmd = 0x2C53;
4526 } else {
4527 cmd = 0x2C51;
4528 }
4529 break;
4530 case 6:
4531 if (j->ver.low == 0x12) {
4532 cmd = 0x2C63;
4533 } else {
4534 cmd = 0x2C61;
4535 }
4536 break;
4537 }
4538 if (ixj_WriteDSPCommand(cmd, j))
4539 return -1;
4540
4541 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4542 return -1;
4543
4544 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4545 return -1;
4546
4547 if (j->flags.recording) {
4548 ixj_aec_start(j, j->aec_level);
4549 }
4550
4551 return 0;
4552 }
4553
4554 static void ixj_play_stop(IXJ *j)
4555 {
4556 if (ixjdebug & 0x0002)
4557 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4558
4559 kfree(j->write_buffer);
4560 j->write_buffer = NULL;
4561 j->write_buffer_size = 0;
4562 if (j->play_mode > -1) {
4563 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4564
4565 j->play_mode = -1;
4566 }
4567 j->flags.playing = 0;
4568 }
4569
4570 static inline int get_play_level(IXJ *j)
4571 {
4572 int retval;
4573
4574 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4575 return j->ssr.high << 8 | j->ssr.low;
4576 retval = j->ssr.high << 8 | j->ssr.low;
4577 retval = (retval * 256) / 240;
4578 return retval;
4579 }
4580
4581 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4582 {
4583 unsigned int mask = 0;
4584
4585 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4586
4587 poll_wait(file_p, &(j->poll_q), wait);
4588 if (j->read_buffer_ready > 0)
4589 mask |= POLLIN | POLLRDNORM; /* readable */
4590 if (j->write_buffers_empty > 0)
4591 mask |= POLLOUT | POLLWRNORM; /* writable */
4592 if (j->ex.bytes)
4593 mask |= POLLPRI;
4594 return mask;
4595 }
4596
4597 static int ixj_play_tone(IXJ *j, char tone)
4598 {
4599 if (!j->tone_state) {
4600 if(ixjdebug & 0x0002) {
4601 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4602 }
4603 if (j->dsp.low == 0x20) {
4604 idle(j);
4605 }
4606 j->tone_start_jif = jiffies;
4607
4608 j->tone_state = 1;
4609 }
4610
4611 j->tone_index = tone;
4612 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4613 return -1;
4614
4615 return 0;
4616 }
4617
4618 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4619 {
4620 j->tone_on_time = arg;
4621
4622 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4623
4624 return -1;
4625
4626 if (ixj_WriteDSPCommand(arg, j))
4627 return -1;
4628
4629 return 0;
4630 }
4631
4632 static int SCI_WaitHighSCI(IXJ *j)
4633 {
4634 int cnt;
4635
4636 j->pld_scrr.byte = inb_p(j->XILINXbase);
4637 if (!j->pld_scrr.bits.sci) {
4638 for (cnt = 0; cnt < 10; cnt++) {
4639 udelay(32);
4640 j->pld_scrr.byte = inb_p(j->XILINXbase);
4641
4642 if ((j->pld_scrr.bits.sci))
4643 return 1;
4644 }
4645 if (ixjdebug & 0x0001)
4646 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4647 return 0;
4648 } else
4649 return 1;
4650 }
4651
4652 static int SCI_WaitLowSCI(IXJ *j)
4653 {
4654 int cnt;
4655
4656 j->pld_scrr.byte = inb_p(j->XILINXbase);
4657 if (j->pld_scrr.bits.sci) {
4658 for (cnt = 0; cnt < 10; cnt++) {
4659 udelay(32);
4660 j->pld_scrr.byte = inb_p(j->XILINXbase);
4661
4662 if (!(j->pld_scrr.bits.sci))
4663 return 1;
4664 }
4665 if (ixjdebug & 0x0001)
4666 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4667 return 0;
4668 } else
4669 return 1;
4670 }
4671
4672 static int SCI_Control(IXJ *j, int control)
4673 {
4674 switch (control) {
4675 case SCI_End:
4676 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4677
4678 j->pld_scrw.bits.c1 = 0; /* to no selection */
4679
4680 break;
4681 case SCI_Enable_DAA:
4682 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4683
4684 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4685
4686 break;
4687 case SCI_Enable_Mixer:
4688 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4689
4690 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4691
4692 break;
4693 case SCI_Enable_EEPROM:
4694 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4695
4696 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4697
4698 break;
4699 default:
4700 return 0;
4701 break;
4702 }
4703 outb_p(j->pld_scrw.byte, j->XILINXbase);
4704
4705 switch (control) {
4706 case SCI_End:
4707 return 1;
4708 break;
4709 case SCI_Enable_DAA:
4710 case SCI_Enable_Mixer:
4711 case SCI_Enable_EEPROM:
4712 if (!SCI_WaitHighSCI(j))
4713 return 0;
4714 break;
4715 default:
4716 return 0;
4717 break;
4718 }
4719 return 1;
4720 }
4721
4722 static int SCI_Prepare(IXJ *j)
4723 {
4724 if (!SCI_Control(j, SCI_End))
4725 return 0;
4726
4727 if (!SCI_WaitLowSCI(j))
4728 return 0;
4729
4730 return 1;
4731 }
4732
4733 static int ixj_get_mixer(long val, IXJ *j)
4734 {
4735 int reg = (val & 0x1F00) >> 8;
4736 return j->mix.vol[reg];
4737 }
4738
4739 static int ixj_mixer(long val, IXJ *j)
4740 {
4741 BYTES bytes;
4742
4743 bytes.high = (val & 0x1F00) >> 8;
4744 bytes.low = val & 0x00FF;
4745
4746 /* save mixer value so we can get back later on */
4747 j->mix.vol[bytes.high] = bytes.low;
4748
4749 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4750
4751 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4752
4753 SCI_Control(j, SCI_Enable_Mixer);
4754
4755 SCI_Control(j, SCI_End);
4756
4757 return 0;
4758 }
4759
4760 static int daa_load(BYTES * p_bytes, IXJ *j)
4761 {
4762 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4763 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4764 if (!SCI_Control(j, SCI_Enable_DAA))
4765 return 0;
4766 else
4767 return 1;
4768 }
4769
4770 static int ixj_daa_cr4(IXJ *j, char reg)
4771 {
4772 BYTES bytes;
4773
4774 switch (j->daa_mode) {
4775 case SOP_PU_SLEEP:
4776 bytes.high = 0x14;
4777 break;
4778 case SOP_PU_RINGING:
4779 bytes.high = 0x54;
4780 break;
4781 case SOP_PU_CONVERSATION:
4782 bytes.high = 0x94;
4783 break;
4784 case SOP_PU_PULSEDIALING:
4785 bytes.high = 0xD4;
4786 break;
4787 }
4788
4789 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4790
4791 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4792 case 0:
4793 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4794 break;
4795 case 1:
4796 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4797 break;
4798 case 2:
4799 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4800 break;
4801 case 3:
4802 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4803 break;
4804 }
4805
4806 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4807
4808 if (!daa_load(&bytes, j))
4809 return 0;
4810
4811 if (!SCI_Prepare(j))
4812 return 0;
4813
4814 return 1;
4815 }
4816
4817 static char daa_int_read(IXJ *j)
4818 {
4819 BYTES bytes;
4820
4821 if (!SCI_Prepare(j))
4822 return 0;
4823
4824 bytes.high = 0x38;
4825 bytes.low = 0x00;
4826 outb_p(bytes.high, j->XILINXbase + 0x03);
4827 outb_p(bytes.low, j->XILINXbase + 0x02);
4828
4829 if (!SCI_Control(j, SCI_Enable_DAA))
4830 return 0;
4831
4832 bytes.high = inb_p(j->XILINXbase + 0x03);
4833 bytes.low = inb_p(j->XILINXbase + 0x02);
4834 if (bytes.low != ALISDAA_ID_BYTE) {
4835 if (ixjdebug & 0x0001)
4836 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4837 return 0;
4838 }
4839 if (!SCI_Control(j, SCI_Enable_DAA))
4840 return 0;
4841 if (!SCI_Control(j, SCI_End))
4842 return 0;
4843
4844 bytes.high = inb_p(j->XILINXbase + 0x03);
4845 bytes.low = inb_p(j->XILINXbase + 0x02);
4846
4847 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4848
4849 return 1;
4850 }
4851
4852 static char daa_CR_read(IXJ *j, int cr)
4853 {
4854 IXJ_WORD wdata;
4855 BYTES bytes;
4856
4857 if (!SCI_Prepare(j))
4858 return 0;
4859
4860 switch (j->daa_mode) {
4861 case SOP_PU_SLEEP:
4862 bytes.high = 0x30 + cr;
4863 break;
4864 case SOP_PU_RINGING:
4865 bytes.high = 0x70 + cr;
4866 break;
4867 case SOP_PU_CONVERSATION:
4868 bytes.high = 0xB0 + cr;
4869 break;
4870 case SOP_PU_PULSEDIALING:
4871 bytes.high = 0xF0 + cr;
4872 break;
4873 }
4874
4875 bytes.low = 0x00;
4876
4877 outb_p(bytes.high, j->XILINXbase + 0x03);
4878 outb_p(bytes.low, j->XILINXbase + 0x02);
4879
4880 if (!SCI_Control(j, SCI_Enable_DAA))
4881 return 0;
4882
4883 bytes.high = inb_p(j->XILINXbase + 0x03);
4884 bytes.low = inb_p(j->XILINXbase + 0x02);
4885 if (bytes.low != ALISDAA_ID_BYTE) {
4886 if (ixjdebug & 0x0001)
4887 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4888 return 0;
4889 }
4890 if (!SCI_Control(j, SCI_Enable_DAA))
4891 return 0;
4892 if (!SCI_Control(j, SCI_End))
4893 return 0;
4894
4895 wdata.word = inw_p(j->XILINXbase + 0x02);
4896
4897 switch(cr){
4898 case 5:
4899 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4900 break;
4901 case 4:
4902 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4903 break;
4904 case 3:
4905 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4906 break;
4907 case 2:
4908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4909 break;
4910 case 1:
4911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4912 break;
4913 case 0:
4914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4915 break;
4916 default:
4917 return 0;
4918 }
4919 return 1;
4920 }
4921
4922 static int ixj_daa_cid_reset(IXJ *j)
4923 {
4924 int i;
4925 BYTES bytes;
4926
4927 if (ixjdebug & 0x0002)
4928 printk("DAA Clearing CID ram\n");
4929
4930 if (!SCI_Prepare(j))
4931 return 0;
4932
4933 bytes.high = 0x58;
4934 bytes.low = 0x00;
4935 outb_p(bytes.high, j->XILINXbase + 0x03);
4936 outb_p(bytes.low, j->XILINXbase + 0x02);
4937
4938 if (!SCI_Control(j, SCI_Enable_DAA))
4939 return 0;
4940
4941 if (!SCI_WaitHighSCI(j))
4942 return 0;
4943
4944 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4945 bytes.high = bytes.low = 0x00;
4946 outb_p(bytes.high, j->XILINXbase + 0x03);
4947
4948 if (i < ALISDAA_CALLERID_SIZE - 1)
4949 outb_p(bytes.low, j->XILINXbase + 0x02);
4950
4951 if (!SCI_Control(j, SCI_Enable_DAA))
4952 return 0;
4953
4954 if (!SCI_WaitHighSCI(j))
4955 return 0;
4956
4957 }
4958
4959 if (!SCI_Control(j, SCI_End))
4960 return 0;
4961
4962 if (ixjdebug & 0x0002)
4963 printk("DAA CID ram cleared\n");
4964
4965 return 1;
4966 }
4967
4968 static int ixj_daa_cid_read(IXJ *j)
4969 {
4970 int i;
4971 BYTES bytes;
4972 char CID[ALISDAA_CALLERID_SIZE], mContinue;
4973 char *pIn, *pOut;
4974
4975 if (!SCI_Prepare(j))
4976 return 0;
4977
4978 bytes.high = 0x78;
4979 bytes.low = 0x00;
4980 outb_p(bytes.high, j->XILINXbase + 0x03);
4981 outb_p(bytes.low, j->XILINXbase + 0x02);
4982
4983 if (!SCI_Control(j, SCI_Enable_DAA))
4984 return 0;
4985
4986 if (!SCI_WaitHighSCI(j))
4987 return 0;
4988
4989 bytes.high = inb_p(j->XILINXbase + 0x03);
4990 bytes.low = inb_p(j->XILINXbase + 0x02);
4991 if (bytes.low != ALISDAA_ID_BYTE) {
4992 if (ixjdebug & 0x0001)
4993 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4994 return 0;
4995 }
4996 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4997 bytes.high = bytes.low = 0x00;
4998 outb_p(bytes.high, j->XILINXbase + 0x03);
4999 outb_p(bytes.low, j->XILINXbase + 0x02);
5000
5001 if (!SCI_Control(j, SCI_Enable_DAA))
5002 return 0;
5003
5004 if (!SCI_WaitHighSCI(j))
5005 return 0;
5006
5007 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5008 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5009 }
5010
5011 if (!SCI_Control(j, SCI_End))
5012 return 0;
5013
5014 pIn = CID;
5015 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5016 mContinue = 1;
5017 while (mContinue) {
5018 if ((pIn[1] & 0x03) == 0x01) {
5019 pOut[0] = pIn[0];
5020 }
5021 if ((pIn[2] & 0x0c) == 0x04) {
5022 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5023 }
5024 if ((pIn[3] & 0x30) == 0x10) {
5025 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5026 }
5027 if ((pIn[4] & 0xc0) == 0x40) {
5028 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5029 } else {
5030 mContinue = FALSE;
5031 }
5032 pIn += 5, pOut += 4;
5033 }
5034 memset(&j->cid, 0, sizeof(PHONE_CID));
5035 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5036 pOut += 4;
5037 strncpy(j->cid.month, pOut, 2);
5038 pOut += 2;
5039 strncpy(j->cid.day, pOut, 2);
5040 pOut += 2;
5041 strncpy(j->cid.hour, pOut, 2);
5042 pOut += 2;
5043 strncpy(j->cid.min, pOut, 2);
5044 pOut += 3;
5045 j->cid.numlen = *pOut;
5046 pOut += 1;
5047 strncpy(j->cid.number, pOut, j->cid.numlen);
5048 pOut += j->cid.numlen + 1;
5049 j->cid.namelen = *pOut;
5050 pOut += 1;
5051 strncpy(j->cid.name, pOut, j->cid.namelen);
5052
5053 ixj_daa_cid_reset(j);
5054 return 1;
5055 }
5056
5057 static char daa_get_version(IXJ *j)
5058 {
5059 BYTES bytes;
5060
5061 if (!SCI_Prepare(j))
5062 return 0;
5063
5064 bytes.high = 0x35;
5065 bytes.low = 0x00;
5066 outb_p(bytes.high, j->XILINXbase + 0x03);
5067 outb_p(bytes.low, j->XILINXbase + 0x02);
5068
5069 if (!SCI_Control(j, SCI_Enable_DAA))
5070 return 0;
5071
5072 bytes.high = inb_p(j->XILINXbase + 0x03);
5073 bytes.low = inb_p(j->XILINXbase + 0x02);
5074 if (bytes.low != ALISDAA_ID_BYTE) {
5075 if (ixjdebug & 0x0001)
5076 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5077 return 0;
5078 }
5079 if (!SCI_Control(j, SCI_Enable_DAA))
5080 return 0;
5081
5082 if (!SCI_Control(j, SCI_End))
5083 return 0;
5084
5085 bytes.high = inb_p(j->XILINXbase + 0x03);
5086 bytes.low = inb_p(j->XILINXbase + 0x02);
5087 if (ixjdebug & 0x0002)
5088 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5089 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5090 return bytes.high;
5091 }
5092
5093 static int daa_set_mode(IXJ *j, int mode)
5094 {
5095 /* NOTE:
5096 The DAA *MUST* be in the conversation mode if the
5097 PSTN line is to be seized (PSTN line off-hook).
5098 Taking the PSTN line off-hook while the DAA is in
5099 a mode other than conversation mode will cause a
5100 hardware failure of the ALIS-A part.
5101
5102 NOTE:
5103 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5104 if the PSTN line is on-hook. Failure to have the PSTN line
5105 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5106 ALIS-A part.
5107 */
5108
5109 BYTES bytes;
5110
5111 j->flags.pstn_rmr = 0;
5112
5113 if (!SCI_Prepare(j))
5114 return 0;
5115
5116 switch (mode) {
5117 case SOP_PU_RESET:
5118 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5119
5120 outb_p(j->pld_scrw.byte, j->XILINXbase);
5121 j->pld_slicw.bits.rly2 = 0;
5122 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5123 bytes.high = 0x10;
5124 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5125 daa_load(&bytes, j);
5126 if (!SCI_Prepare(j))
5127 return 0;
5128
5129 j->daa_mode = SOP_PU_SLEEP;
5130 break;
5131 case SOP_PU_SLEEP:
5132 if(j->daa_mode == SOP_PU_SLEEP)
5133 {
5134 break;
5135 }
5136 if (ixjdebug & 0x0008)
5137 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5138 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5139 {
5140 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5141
5142 outb_p(j->pld_scrw.byte, j->XILINXbase);
5143 j->pld_slicw.bits.rly2 = 0;
5144 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5145 bytes.high = 0x10;
5146 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5147 daa_load(&bytes, j);
5148 if (!SCI_Prepare(j))
5149 return 0;
5150 }
5151 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5152
5153 outb_p(j->pld_scrw.byte, j->XILINXbase);
5154 j->pld_slicw.bits.rly2 = 0;
5155 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5156 bytes.high = 0x10;
5157 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5158 daa_load(&bytes, j);
5159 if (!SCI_Prepare(j))
5160 return 0;
5161
5162 j->daa_mode = SOP_PU_SLEEP;
5163 j->flags.pstn_ringing = 0;
5164 j->ex.bits.pstn_ring = 0;
5165 j->pstn_sleeptil = jiffies + (hertz / 4);
5166 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5167 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5168 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5169 break;
5170 case SOP_PU_RINGING:
5171 if (ixjdebug & 0x0008)
5172 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5173 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5174
5175 outb_p(j->pld_scrw.byte, j->XILINXbase);
5176 j->pld_slicw.bits.rly2 = 0;
5177 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5178 bytes.high = 0x50;
5179 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5180 daa_load(&bytes, j);
5181 if (!SCI_Prepare(j))
5182 return 0;
5183 j->daa_mode = SOP_PU_RINGING;
5184 break;
5185 case SOP_PU_CONVERSATION:
5186 if (ixjdebug & 0x0008)
5187 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5188 bytes.high = 0x90;
5189 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5190 daa_load(&bytes, j);
5191 if (!SCI_Prepare(j))
5192 return 0;
5193 j->pld_slicw.bits.rly2 = 1;
5194 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5195 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5196
5197 outb_p(j->pld_scrw.byte, j->XILINXbase);
5198 j->daa_mode = SOP_PU_CONVERSATION;
5199 j->flags.pstn_ringing = 0;
5200 j->ex.bits.pstn_ring = 0;
5201 j->pstn_sleeptil = jiffies;
5202 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5203 break;
5204 case SOP_PU_PULSEDIALING:
5205 if (ixjdebug & 0x0008)
5206 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5207 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5208
5209 outb_p(j->pld_scrw.byte, j->XILINXbase);
5210 j->pld_slicw.bits.rly2 = 0;
5211 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5212 bytes.high = 0xD0;
5213 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5214 daa_load(&bytes, j);
5215 if (!SCI_Prepare(j))
5216 return 0;
5217 j->daa_mode = SOP_PU_PULSEDIALING;
5218 break;
5219 default:
5220 break;
5221 }
5222 return 1;
5223 }
5224
5225 static int ixj_daa_write(IXJ *j)
5226 {
5227 BYTES bytes;
5228
5229 j->flags.pstncheck = 1;
5230
5231 daa_set_mode(j, SOP_PU_SLEEP);
5232
5233 if (!SCI_Prepare(j))
5234 return 0;
5235
5236 outb_p(j->pld_scrw.byte, j->XILINXbase);
5237
5238 bytes.high = 0x14;
5239 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5240 if (!daa_load(&bytes, j))
5241 return 0;
5242
5243 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5244 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5245 if (!daa_load(&bytes, j))
5246 return 0;
5247
5248 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5249 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5250 if (!daa_load(&bytes, j))
5251 return 0;
5252
5253 if (!SCI_Prepare(j))
5254 return 0;
5255
5256 bytes.high = 0x1F;
5257 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5258 if (!daa_load(&bytes, j))
5259 return 0;
5260
5261 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5262 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5263 if (!daa_load(&bytes, j))
5264 return 0;
5265
5266 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5267 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5268 if (!daa_load(&bytes, j))
5269 return 0;
5270
5271 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5272 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5273 if (!daa_load(&bytes, j))
5274 return 0;
5275
5276 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5277 bytes.low = 0x00;
5278 if (!daa_load(&bytes, j))
5279 return 0;
5280
5281 if (!SCI_Prepare(j))
5282 return 0;
5283
5284 bytes.high = 0x00;
5285 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5286 if (!daa_load(&bytes, j))
5287 return 0;
5288
5289 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5290 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5291 if (!daa_load(&bytes, j))
5292 return 0;
5293
5294 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5295 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5296 if (!daa_load(&bytes, j))
5297 return 0;
5298
5299 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5300 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5301 if (!daa_load(&bytes, j))
5302 return 0;
5303
5304 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5305 bytes.low = 0x00;
5306 if (!daa_load(&bytes, j))
5307 return 0;
5308
5309 if (!SCI_Control(j, SCI_End))
5310 return 0;
5311 if (!SCI_WaitLowSCI(j))
5312 return 0;
5313
5314 bytes.high = 0x01;
5315 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5316 if (!daa_load(&bytes, j))
5317 return 0;
5318
5319 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5320 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5321 if (!daa_load(&bytes, j))
5322 return 0;
5323
5324 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5325 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5326 if (!daa_load(&bytes, j))
5327 return 0;
5328
5329 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5330 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5331 if (!daa_load(&bytes, j))
5332 return 0;
5333
5334 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5335 bytes.low = 0x00;
5336 if (!daa_load(&bytes, j))
5337 return 0;
5338
5339 if (!SCI_Control(j, SCI_End))
5340 return 0;
5341 if (!SCI_WaitLowSCI(j))
5342 return 0;
5343
5344 bytes.high = 0x02;
5345 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5346 if (!daa_load(&bytes, j))
5347 return 0;
5348
5349 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5350 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5351 if (!daa_load(&bytes, j))
5352 return 0;
5353
5354 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5355 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5356 if (!daa_load(&bytes, j))
5357 return 0;
5358
5359 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5360 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5361 if (!daa_load(&bytes, j))
5362 return 0;
5363
5364 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5365 bytes.low = 0x00;
5366 if (!daa_load(&bytes, j))
5367 return 0;
5368
5369 if (!SCI_Control(j, SCI_End))
5370 return 0;
5371 if (!SCI_WaitLowSCI(j))
5372 return 0;
5373
5374 bytes.high = 0x03;
5375 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5376 if (!daa_load(&bytes, j))
5377 return 0;
5378
5379 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5380 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5381 if (!daa_load(&bytes, j))
5382 return 0;
5383
5384 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5385 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5386 if (!daa_load(&bytes, j))
5387 return 0;
5388
5389 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5390 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5391 if (!daa_load(&bytes, j))
5392 return 0;
5393
5394 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5395 bytes.low = 0x00;
5396 if (!daa_load(&bytes, j))
5397 return 0;
5398
5399 if (!SCI_Control(j, SCI_End))
5400 return 0;
5401 if (!SCI_WaitLowSCI(j))
5402 return 0;
5403
5404 bytes.high = 0x04;
5405 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5406 if (!daa_load(&bytes, j))
5407 return 0;
5408
5409 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5410 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5411 if (!daa_load(&bytes, j))
5412 return 0;
5413
5414 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5415 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5416 if (!daa_load(&bytes, j))
5417 return 0;
5418
5419 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5420 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5421 if (!daa_load(&bytes, j))
5422 return 0;
5423
5424 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5425 bytes.low = 0x00;
5426 if (!daa_load(&bytes, j))
5427 return 0;
5428
5429 if (!SCI_Control(j, SCI_End))
5430 return 0;
5431 if (!SCI_WaitLowSCI(j))
5432 return 0;
5433
5434 bytes.high = 0x05;
5435 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5436 if (!daa_load(&bytes, j))
5437 return 0;
5438
5439 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5440 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5441 if (!daa_load(&bytes, j))
5442 return 0;
5443
5444 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5445 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5446 if (!daa_load(&bytes, j))
5447 return 0;
5448
5449 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5450 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5451 if (!daa_load(&bytes, j))
5452 return 0;
5453
5454 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5455 bytes.low = 0x00;
5456 if (!daa_load(&bytes, j))
5457 return 0;
5458
5459 if (!SCI_Control(j, SCI_End))
5460 return 0;
5461 if (!SCI_WaitLowSCI(j))
5462 return 0;
5463
5464 bytes.high = 0x06;
5465 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5466 if (!daa_load(&bytes, j))
5467 return 0;
5468
5469 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5470 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5471 if (!daa_load(&bytes, j))
5472 return 0;
5473
5474 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5475 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5476 if (!daa_load(&bytes, j))
5477 return 0;
5478
5479 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5480 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5481 if (!daa_load(&bytes, j))
5482 return 0;
5483
5484 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5485 bytes.low = 0x00;
5486 if (!daa_load(&bytes, j))
5487 return 0;
5488
5489 if (!SCI_Control(j, SCI_End))
5490 return 0;
5491 if (!SCI_WaitLowSCI(j))
5492 return 0;
5493
5494 bytes.high = 0x07;
5495 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5496 if (!daa_load(&bytes, j))
5497 return 0;
5498
5499 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5500 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5501 if (!daa_load(&bytes, j))
5502 return 0;
5503
5504 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5505 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5506 if (!daa_load(&bytes, j))
5507 return 0;
5508
5509 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5510 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5511 if (!daa_load(&bytes, j))
5512 return 0;
5513
5514 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5515 bytes.low = 0x00;
5516 if (!daa_load(&bytes, j))
5517 return 0;
5518
5519 if (!SCI_Control(j, SCI_End))
5520 return 0;
5521 if (!SCI_WaitLowSCI(j))
5522 return 0;
5523
5524 bytes.high = 0x08;
5525 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5526 if (!daa_load(&bytes, j))
5527 return 0;
5528
5529 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5530 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5531 if (!daa_load(&bytes, j))
5532 return 0;
5533
5534 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5535 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5536 if (!daa_load(&bytes, j))
5537 return 0;
5538
5539 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5540 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5541 if (!daa_load(&bytes, j))
5542 return 0;
5543
5544 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5545 bytes.low = 0x00;
5546 if (!daa_load(&bytes, j))
5547 return 0;
5548
5549 if (!SCI_Control(j, SCI_End))
5550 return 0;
5551 if (!SCI_WaitLowSCI(j))
5552 return 0;
5553
5554 bytes.high = 0x09;
5555 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5556 if (!daa_load(&bytes, j))
5557 return 0;
5558
5559 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5560 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5561 if (!daa_load(&bytes, j))
5562 return 0;
5563
5564 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5565 bytes.low = 0x00;
5566 if (!daa_load(&bytes, j))
5567 return 0;
5568
5569 if (!SCI_Control(j, SCI_End))
5570 return 0;
5571 if (!SCI_WaitLowSCI(j))
5572 return 0;
5573
5574 bytes.high = 0x0A;
5575 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5576 if (!daa_load(&bytes, j))
5577 return 0;
5578
5579 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5580 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5581 if (!daa_load(&bytes, j))
5582 return 0;
5583
5584 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5585 bytes.low = 0x00;
5586 if (!daa_load(&bytes, j))
5587 return 0;
5588
5589 if (!SCI_Control(j, SCI_End))
5590 return 0;
5591 if (!SCI_WaitLowSCI(j))
5592 return 0;
5593
5594 bytes.high = 0x0B;
5595 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5596 if (!daa_load(&bytes, j))
5597 return 0;
5598
5599 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5600 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5601 if (!daa_load(&bytes, j))
5602 return 0;
5603
5604 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5605 bytes.low = 0x00;
5606 if (!daa_load(&bytes, j))
5607 return 0;
5608
5609 if (!SCI_Control(j, SCI_End))
5610 return 0;
5611 if (!SCI_WaitLowSCI(j))
5612 return 0;
5613
5614 bytes.high = 0x0C;
5615 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5616 if (!daa_load(&bytes, j))
5617 return 0;
5618
5619 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5620 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5621 if (!daa_load(&bytes, j))
5622 return 0;
5623
5624 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5625 bytes.low = 0x00;
5626 if (!daa_load(&bytes, j))
5627 return 0;
5628
5629 if (!SCI_Control(j, SCI_End))
5630 return 0;
5631 if (!SCI_WaitLowSCI(j))
5632 return 0;
5633
5634 bytes.high = 0x0D;
5635 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5636 if (!daa_load(&bytes, j))
5637 return 0;
5638
5639 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5640 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5641 if (!daa_load(&bytes, j))
5642 return 0;
5643
5644 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5645 bytes.low = 0x00;
5646 if (!daa_load(&bytes, j))
5647 return 0;
5648
5649 if (!SCI_Control(j, SCI_End))
5650 return 0;
5651 if (!SCI_WaitLowSCI(j))
5652 return 0;
5653
5654 bytes.high = 0x0E;
5655 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5656 if (!daa_load(&bytes, j))
5657 return 0;
5658
5659 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5660 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5661 if (!daa_load(&bytes, j))
5662 return 0;
5663
5664 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5665 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5666 if (!daa_load(&bytes, j))
5667 return 0;
5668
5669 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5670 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5671 if (!daa_load(&bytes, j))
5672 return 0;
5673
5674 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5675 bytes.low = 0x00;
5676 if (!daa_load(&bytes, j))
5677 return 0;
5678
5679 if (!SCI_Control(j, SCI_End))
5680 return 0;
5681 if (!SCI_WaitLowSCI(j))
5682 return 0;
5683
5684 bytes.high = 0x0F;
5685 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5686 if (!daa_load(&bytes, j))
5687 return 0;
5688
5689 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5690 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5691 if (!daa_load(&bytes, j))
5692 return 0;
5693
5694 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5695 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5696 if (!daa_load(&bytes, j))
5697 return 0;
5698
5699 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5700 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5701 if (!daa_load(&bytes, j))
5702 return 0;
5703
5704 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5705 bytes.low = 0x00;
5706 if (!daa_load(&bytes, j))
5707 return 0;
5708
5709 udelay(32);
5710 j->pld_scrr.byte = inb_p(j->XILINXbase);
5711 if (!SCI_Control(j, SCI_End))
5712 return 0;
5713
5714 outb_p(j->pld_scrw.byte, j->XILINXbase);
5715
5716 if (ixjdebug & 0x0002)
5717 printk("DAA Coefficients Loaded\n");
5718
5719 j->flags.pstncheck = 0;
5720 return 1;
5721 }
5722
5723 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5724 {
5725 j->tone_off_time = arg;
5726 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5727
5728 return -1;
5729 if (ixj_WriteDSPCommand(arg, j))
5730 return -1;
5731 return 0;
5732 }
5733
5734 static int ixj_get_tone_on(IXJ *j)
5735 {
5736 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5737
5738 return -1;
5739 return 0;
5740 }
5741
5742 static int ixj_get_tone_off(IXJ *j)
5743 {
5744 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5745
5746 return -1;
5747 return 0;
5748 }
5749
5750 static void ixj_busytone(IXJ *j)
5751 {
5752 j->flags.ringback = 0;
5753 j->flags.dialtone = 0;
5754 j->flags.busytone = 1;
5755 ixj_set_tone_on(0x07D0, j);
5756 ixj_set_tone_off(0x07D0, j);
5757 ixj_play_tone(j, 27);
5758 }
5759
5760 static void ixj_dialtone(IXJ *j)
5761 {
5762 j->flags.ringback = 0;
5763 j->flags.dialtone = 1;
5764 j->flags.busytone = 0;
5765 if (j->dsp.low == 0x20) {
5766 return;
5767 } else {
5768 ixj_set_tone_on(0xFFFF, j);
5769 ixj_set_tone_off(0x0000, j);
5770 ixj_play_tone(j, 25);
5771 }
5772 }
5773
5774 static void ixj_cpt_stop(IXJ *j)
5775 {
5776 if(j->tone_state || j->tone_cadence_state)
5777 {
5778 j->flags.dialtone = 0;
5779 j->flags.busytone = 0;
5780 j->flags.ringback = 0;
5781 ixj_set_tone_on(0x0001, j);
5782 ixj_set_tone_off(0x0000, j);
5783 ixj_play_tone(j, 0);
5784 j->tone_state = j->tone_cadence_state = 0;
5785 if (j->cadence_t) {
5786 kfree(j->cadence_t->ce);
5787 kfree(j->cadence_t);
5788 j->cadence_t = NULL;
5789 }
5790 }
5791 if (j->play_mode == -1 && j->rec_mode == -1)
5792 idle(j);
5793 if (j->play_mode != -1 && j->dsp.low == 0x20)
5794 ixj_play_start(j);
5795 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5796 ixj_record_start(j);
5797 }
5798
5799 static void ixj_ringback(IXJ *j)
5800 {
5801 j->flags.busytone = 0;
5802 j->flags.dialtone = 0;
5803 j->flags.ringback = 1;
5804 ixj_set_tone_on(0x0FA0, j);
5805 ixj_set_tone_off(0x2EE0, j);
5806 ixj_play_tone(j, 26);
5807 }
5808
5809 static void ixj_testram(IXJ *j)
5810 {
5811 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5812 }
5813
5814 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5815 {
5816 ixj_cadence *lcp;
5817 IXJ_CADENCE_ELEMENT __user *cep;
5818 IXJ_CADENCE_ELEMENT *lcep;
5819 IXJ_TONE ti;
5820 int err;
5821
5822 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5823 if (lcp == NULL)
5824 return -ENOMEM;
5825
5826 err = -EFAULT;
5827 if (copy_from_user(&lcp->elements_used,
5828 &cp->elements_used, sizeof(int)))
5829 goto out;
5830 if (copy_from_user(&lcp->termination,
5831 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5832 goto out;
5833 if (get_user(cep, &cp->ce))
5834 goto out;
5835
5836 err = -EINVAL;
5837 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5838 goto out;
5839
5840 err = -ENOMEM;
5841 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5842 if (!lcep)
5843 goto out;
5844
5845 err = -EFAULT;
5846 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5847 goto out1;
5848
5849 if (j->cadence_t) {
5850 kfree(j->cadence_t->ce);
5851 kfree(j->cadence_t);
5852 }
5853 lcp->ce = (void *) lcep;
5854 j->cadence_t = lcp;
5855 j->tone_cadence_state = 0;
5856 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5857 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5858 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5859 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5860 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5861 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5862 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5863 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5864 ixj_init_tone(j, &ti);
5865 }
5866 ixj_play_tone(j, lcp->ce[0].index);
5867 return 1;
5868 out1:
5869 kfree(lcep);
5870 out:
5871 kfree(lcp);
5872 return err;
5873 }
5874
5875 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5876 {
5877 IXJ_FILTER_CADENCE *lcp;
5878 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5879 if (lcp == NULL) {
5880 if(ixjdebug & 0x0001) {
5881 printk(KERN_INFO "Could not allocate memory for cadence\n");
5882 }
5883 return -ENOMEM;
5884 }
5885 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5886 if(ixjdebug & 0x0001) {
5887 printk(KERN_INFO "Could not copy cadence to kernel\n");
5888 }
5889 kfree(lcp);
5890 return -EFAULT;
5891 }
5892 if (lcp->filter > 5) {
5893 if(ixjdebug & 0x0001) {
5894 printk(KERN_INFO "Cadence out of range\n");
5895 }
5896 kfree(lcp);
5897 return -1;
5898 }
5899 j->cadence_f[lcp->filter].state = 0;
5900 j->cadence_f[lcp->filter].enable = lcp->enable;
5901 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5902 j->cadence_f[lcp->filter].on1 = lcp->on1;
5903 j->cadence_f[lcp->filter].on1min = 0;
5904 j->cadence_f[lcp->filter].on1max = 0;
5905 j->cadence_f[lcp->filter].off1 = lcp->off1;
5906 j->cadence_f[lcp->filter].off1min = 0;
5907 j->cadence_f[lcp->filter].off1max = 0;
5908 j->cadence_f[lcp->filter].on2 = lcp->on2;
5909 j->cadence_f[lcp->filter].on2min = 0;
5910 j->cadence_f[lcp->filter].on2max = 0;
5911 j->cadence_f[lcp->filter].off2 = lcp->off2;
5912 j->cadence_f[lcp->filter].off2min = 0;
5913 j->cadence_f[lcp->filter].off2max = 0;
5914 j->cadence_f[lcp->filter].on3 = lcp->on3;
5915 j->cadence_f[lcp->filter].on3min = 0;
5916 j->cadence_f[lcp->filter].on3max = 0;
5917 j->cadence_f[lcp->filter].off3 = lcp->off3;
5918 j->cadence_f[lcp->filter].off3min = 0;
5919 j->cadence_f[lcp->filter].off3max = 0;
5920 if(ixjdebug & 0x0002) {
5921 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5922 }
5923 kfree(lcp);
5924 return 0;
5925 }
5926
5927 static void add_caps(IXJ *j)
5928 {
5929 j->caps = 0;
5930 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5931 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5932 j->caplist[j->caps].captype = vendor;
5933 j->caplist[j->caps].handle = j->caps++;
5934 j->caplist[j->caps].captype = device;
5935 switch (j->cardtype) {
5936 case QTI_PHONEJACK:
5937 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5938 break;
5939 case QTI_LINEJACK:
5940 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5941 break;
5942 case QTI_PHONEJACK_LITE:
5943 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5944 break;
5945 case QTI_PHONEJACK_PCI:
5946 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5947 break;
5948 case QTI_PHONECARD:
5949 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5950 break;
5951 }
5952 j->caplist[j->caps].cap = j->cardtype;
5953 j->caplist[j->caps].handle = j->caps++;
5954 strcpy(j->caplist[j->caps].desc, "POTS");
5955 j->caplist[j->caps].captype = port;
5956 j->caplist[j->caps].cap = pots;
5957 j->caplist[j->caps].handle = 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 default:
5970 break;
5971 }
5972
5973 /* add devices that can do handset */
5974 switch (j->cardtype) {
5975 case QTI_PHONEJACK:
5976 strcpy(j->caplist[j->caps].desc, "HANDSET");
5977 j->caplist[j->caps].captype = port;
5978 j->caplist[j->caps].cap = handset;
5979 j->caplist[j->caps].handle = j->caps++;
5980 break;
5981 default:
5982 break;
5983 }
5984
5985 /* add devices that can do PSTN */
5986 switch (j->cardtype) {
5987 case QTI_LINEJACK:
5988 strcpy(j->caplist[j->caps].desc, "PSTN");
5989 j->caplist[j->caps].captype = port;
5990 j->caplist[j->caps].cap = pstn;
5991 j->caplist[j->caps].handle = j->caps++;
5992 break;
5993 default:
5994 break;
5995 }
5996
5997 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5998 strcpy(j->caplist[j->caps].desc, "ULAW");
5999 j->caplist[j->caps].captype = codec;
6000 j->caplist[j->caps].cap = ULAW;
6001 j->caplist[j->caps].handle = j->caps++;
6002
6003 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6004 j->caplist[j->caps].captype = codec;
6005 j->caplist[j->caps].cap = LINEAR16;
6006 j->caplist[j->caps].handle = j->caps++;
6007
6008 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6009 j->caplist[j->caps].captype = codec;
6010 j->caplist[j->caps].cap = LINEAR8;
6011 j->caplist[j->caps].handle = j->caps++;
6012
6013 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6014 j->caplist[j->caps].captype = codec;
6015 j->caplist[j->caps].cap = WSS;
6016 j->caplist[j->caps].handle = j->caps++;
6017
6018 /* software ALAW codec, made from ULAW */
6019 strcpy(j->caplist[j->caps].desc, "ALAW");
6020 j->caplist[j->caps].captype = codec;
6021 j->caplist[j->caps].cap = ALAW;
6022 j->caplist[j->caps].handle = j->caps++;
6023
6024 /* version 12 of the 8020 does the following codecs in a broken way */
6025 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6026 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6027 j->caplist[j->caps].captype = codec;
6028 j->caplist[j->caps].cap = G723_63;
6029 j->caplist[j->caps].handle = j->caps++;
6030
6031 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6032 j->caplist[j->caps].captype = codec;
6033 j->caplist[j->caps].cap = G723_53;
6034 j->caplist[j->caps].handle = j->caps++;
6035
6036 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6037 j->caplist[j->caps].captype = codec;
6038 j->caplist[j->caps].cap = TS48;
6039 j->caplist[j->caps].handle = j->caps++;
6040
6041 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6042 j->caplist[j->caps].captype = codec;
6043 j->caplist[j->caps].cap = TS41;
6044 j->caplist[j->caps].handle = j->caps++;
6045 }
6046
6047 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6048 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6049 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6050 j->caplist[j->caps].captype = codec;
6051 j->caplist[j->caps].cap = TS85;
6052 j->caplist[j->caps].handle = j->caps++;
6053 }
6054
6055 /* 8021 chips can do G728 */
6056 if (j->dsp.low == 0x21) {
6057 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6058 j->caplist[j->caps].captype = codec;
6059 j->caplist[j->caps].cap = G728;
6060 j->caplist[j->caps].handle = j->caps++;
6061 }
6062
6063 /* 8021/8022 chips can do G729 if loaded */
6064 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6065 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6066 j->caplist[j->caps].captype = codec;
6067 j->caplist[j->caps].cap = G729;
6068 j->caplist[j->caps].handle = j->caps++;
6069 }
6070 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6071 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6072 j->caplist[j->caps].captype = codec;
6073 j->caplist[j->caps].cap = G729B;
6074 j->caplist[j->caps].handle = j->caps++;
6075 }
6076 }
6077
6078 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6079 {
6080 int cnt;
6081 int retval = 0;
6082 for (cnt = 0; cnt < j->caps; cnt++) {
6083 if (pcreq->captype == j->caplist[cnt].captype
6084 && pcreq->cap == j->caplist[cnt].cap) {
6085 retval = 1;
6086 break;
6087 }
6088 }
6089 return retval;
6090 }
6091
6092 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6093 {
6094 IXJ_TONE ti;
6095 IXJ_FILTER jf;
6096 IXJ_FILTER_RAW jfr;
6097 void __user *argp = (void __user *)arg;
6098
6099 unsigned int raise, mant;
6100 unsigned int minor = iminor(inode);
6101 int board = NUM(inode);
6102
6103 IXJ *j = get_ixj(NUM(inode));
6104
6105 int retval = 0;
6106
6107 /*
6108 * Set up locks to ensure that only one process is talking to the DSP at a time.
6109 * This is necessary to keep the DSP from locking up.
6110 */
6111 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6112 schedule_timeout_interruptible(1);
6113 if (ixjdebug & 0x0040)
6114 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6115 if (minor >= IXJMAX) {
6116 clear_bit(board, &j->busyflags);
6117 return -ENODEV;
6118 }
6119 /*
6120 * Check ioctls only root can use.
6121 */
6122 if (!capable(CAP_SYS_ADMIN)) {
6123 switch (cmd) {
6124 case IXJCTL_TESTRAM:
6125 case IXJCTL_HZ:
6126 retval = -EPERM;
6127 }
6128 }
6129 switch (cmd) {
6130 case IXJCTL_TESTRAM:
6131 ixj_testram(j);
6132 retval = (j->ssr.high << 8) + j->ssr.low;
6133 break;
6134 case IXJCTL_CARDTYPE:
6135 retval = j->cardtype;
6136 break;
6137 case IXJCTL_SERIAL:
6138 retval = j->serial;
6139 break;
6140 case IXJCTL_VERSION:
6141 {
6142 char arg_str[100];
6143 snprintf(arg_str, sizeof(arg_str),
6144 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6145 IXJ_VER_MINOR, IXJ_BLD_VER);
6146 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6147 retval = -EFAULT;
6148 }
6149 break;
6150 case PHONE_RING_CADENCE:
6151 j->ring_cadence = arg;
6152 break;
6153 case IXJCTL_CIDCW:
6154 if(arg) {
6155 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6156 retval = -EFAULT;
6157 break;
6158 }
6159 } else {
6160 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6161 }
6162 ixj_write_cidcw(j);
6163 break;
6164 /* Binary compatbility */
6165 case OLD_PHONE_RING_START:
6166 arg = 0;
6167 /* Fall through */
6168 case PHONE_RING_START:
6169 if(arg) {
6170 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6171 retval = -EFAULT;
6172 break;
6173 }
6174 ixj_write_cid(j);
6175 } else {
6176 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6177 }
6178 ixj_ring_start(j);
6179 break;
6180 case PHONE_RING_STOP:
6181 j->flags.cringing = 0;
6182 if(j->cadence_f[5].enable) {
6183 j->cadence_f[5].state = 0;
6184 }
6185 ixj_ring_off(j);
6186 break;
6187 case PHONE_RING:
6188 retval = ixj_ring(j);
6189 break;
6190 case PHONE_EXCEPTION:
6191 retval = j->ex.bytes;
6192 if(j->ex.bits.flash) {
6193 j->flash_end = 0;
6194 j->ex.bits.flash = 0;
6195 }
6196 j->ex.bits.pstn_ring = 0;
6197 j->ex.bits.caller_id = 0;
6198 j->ex.bits.pstn_wink = 0;
6199 j->ex.bits.f0 = 0;
6200 j->ex.bits.f1 = 0;
6201 j->ex.bits.f2 = 0;
6202 j->ex.bits.f3 = 0;
6203 j->ex.bits.fc0 = 0;
6204 j->ex.bits.fc1 = 0;
6205 j->ex.bits.fc2 = 0;
6206 j->ex.bits.fc3 = 0;
6207 j->ex.bits.reserved = 0;
6208 break;
6209 case PHONE_HOOKSTATE:
6210 j->ex.bits.hookstate = 0;
6211 retval = j->hookstate; //j->r_hook;
6212 break;
6213 case IXJCTL_SET_LED:
6214 LED_SetState(arg, j);
6215 break;
6216 case PHONE_FRAME:
6217 retval = set_base_frame(j, arg);
6218 break;
6219 case PHONE_REC_CODEC:
6220 retval = set_rec_codec(j, arg);
6221 break;
6222 case PHONE_VAD:
6223 ixj_vad(j, arg);
6224 break;
6225 case PHONE_REC_START:
6226 ixj_record_start(j);
6227 break;
6228 case PHONE_REC_STOP:
6229 ixj_record_stop(j);
6230 break;
6231 case PHONE_REC_DEPTH:
6232 set_rec_depth(j, arg);
6233 break;
6234 case PHONE_REC_VOLUME:
6235 if(arg == -1) {
6236 retval = get_rec_volume(j);
6237 }
6238 else {
6239 set_rec_volume(j, arg);
6240 retval = arg;
6241 }
6242 break;
6243 case PHONE_REC_VOLUME_LINEAR:
6244 if(arg == -1) {
6245 retval = get_rec_volume_linear(j);
6246 }
6247 else {
6248 set_rec_volume_linear(j, arg);
6249 retval = arg;
6250 }
6251 break;
6252 case IXJCTL_DTMF_PRESCALE:
6253 if(arg == -1) {
6254 retval = get_dtmf_prescale(j);
6255 }
6256 else {
6257 set_dtmf_prescale(j, arg);
6258 retval = arg;
6259 }
6260 break;
6261 case PHONE_REC_LEVEL:
6262 retval = get_rec_level(j);
6263 break;
6264 case IXJCTL_SC_RXG:
6265 retval = ixj_siadc(j, arg);
6266 break;
6267 case IXJCTL_SC_TXG:
6268 retval = ixj_sidac(j, arg);
6269 break;
6270 case IXJCTL_AEC_START:
6271 ixj_aec_start(j, arg);
6272 break;
6273 case IXJCTL_AEC_STOP:
6274 aec_stop(j);
6275 break;
6276 case IXJCTL_AEC_GET_LEVEL:
6277 retval = j->aec_level;
6278 break;
6279 case PHONE_PLAY_CODEC:
6280 retval = set_play_codec(j, arg);
6281 break;
6282 case PHONE_PLAY_START:
6283 retval = ixj_play_start(j);
6284 break;
6285 case PHONE_PLAY_STOP:
6286 ixj_play_stop(j);
6287 break;
6288 case PHONE_PLAY_DEPTH:
6289 set_play_depth(j, arg);
6290 break;
6291 case PHONE_PLAY_VOLUME:
6292 if(arg == -1) {
6293 retval = get_play_volume(j);
6294 }
6295 else {
6296 set_play_volume(j, arg);
6297 retval = arg;
6298 }
6299 break;
6300 case PHONE_PLAY_VOLUME_LINEAR:
6301 if(arg == -1) {
6302 retval = get_play_volume_linear(j);
6303 }
6304 else {
6305 set_play_volume_linear(j, arg);
6306 retval = arg;
6307 }
6308 break;
6309 case PHONE_PLAY_LEVEL:
6310 retval = get_play_level(j);
6311 break;
6312 case IXJCTL_DSP_TYPE:
6313 retval = (j->dsp.high << 8) + j->dsp.low;
6314 break;
6315 case IXJCTL_DSP_VERSION:
6316 retval = (j->ver.high << 8) + j->ver.low;
6317 break;
6318 case IXJCTL_HZ:
6319 hertz = arg;
6320 break;
6321 case IXJCTL_RATE:
6322 if (arg > hertz)
6323 retval = -1;
6324 else
6325 samplerate = arg;
6326 break;
6327 case IXJCTL_DRYBUFFER_READ:
6328 put_user(j->drybuffer, (unsigned long __user *) argp);
6329 break;
6330 case IXJCTL_DRYBUFFER_CLEAR:
6331 j->drybuffer = 0;
6332 break;
6333 case IXJCTL_FRAMES_READ:
6334 put_user(j->framesread, (unsigned long __user *) argp);
6335 break;
6336 case IXJCTL_FRAMES_WRITTEN:
6337 put_user(j->frameswritten, (unsigned long __user *) argp);
6338 break;
6339 case IXJCTL_READ_WAIT:
6340 put_user(j->read_wait, (unsigned long __user *) argp);
6341 break;
6342 case IXJCTL_WRITE_WAIT:
6343 put_user(j->write_wait, (unsigned long __user *) argp);
6344 break;
6345 case PHONE_MAXRINGS:
6346 j->maxrings = arg;
6347 break;
6348 case PHONE_SET_TONE_ON_TIME:
6349 ixj_set_tone_on(arg, j);
6350 break;
6351 case PHONE_SET_TONE_OFF_TIME:
6352 ixj_set_tone_off(arg, j);
6353 break;
6354 case PHONE_GET_TONE_ON_TIME:
6355 if (ixj_get_tone_on(j)) {
6356 retval = -1;
6357 } else {
6358 retval = (j->ssr.high << 8) + j->ssr.low;
6359 }
6360 break;
6361 case PHONE_GET_TONE_OFF_TIME:
6362 if (ixj_get_tone_off(j)) {
6363 retval = -1;
6364 } else {
6365 retval = (j->ssr.high << 8) + j->ssr.low;
6366 }
6367 break;
6368 case PHONE_PLAY_TONE:
6369 if (!j->tone_state)
6370 retval = ixj_play_tone(j, arg);
6371 else
6372 retval = -1;
6373 break;
6374 case PHONE_GET_TONE_STATE:
6375 retval = j->tone_state;
6376 break;
6377 case PHONE_DTMF_READY:
6378 retval = j->ex.bits.dtmf_ready;
6379 break;
6380 case PHONE_GET_DTMF:
6381 if (ixj_hookstate(j)) {
6382 if (j->dtmf_rp != j->dtmf_wp) {
6383 retval = j->dtmfbuffer[j->dtmf_rp];
6384 j->dtmf_rp++;
6385 if (j->dtmf_rp == 79)
6386 j->dtmf_rp = 0;
6387 if (j->dtmf_rp == j->dtmf_wp) {
6388 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6389 }
6390 }
6391 }
6392 break;
6393 case PHONE_GET_DTMF_ASCII:
6394 if (ixj_hookstate(j)) {
6395 if (j->dtmf_rp != j->dtmf_wp) {
6396 switch (j->dtmfbuffer[j->dtmf_rp]) {
6397 case 10:
6398 retval = 42; /* '*'; */
6399
6400 break;
6401 case 11:
6402 retval = 48; /*'0'; */
6403
6404 break;
6405 case 12:
6406 retval = 35; /*'#'; */
6407
6408 break;
6409 case 28:
6410 retval = 65; /*'A'; */
6411
6412 break;
6413 case 29:
6414 retval = 66; /*'B'; */
6415
6416 break;
6417 case 30:
6418 retval = 67; /*'C'; */
6419
6420 break;
6421 case 31:
6422 retval = 68; /*'D'; */
6423
6424 break;
6425 default:
6426 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6427 break;
6428 }
6429 j->dtmf_rp++;
6430 if (j->dtmf_rp == 79)
6431 j->dtmf_rp = 0;
6432 if(j->dtmf_rp == j->dtmf_wp)
6433 {
6434 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6435 }
6436 }
6437 }
6438 break;
6439 case PHONE_DTMF_OOB:
6440 j->flags.dtmf_oob = arg;
6441 break;
6442 case PHONE_DIALTONE:
6443 ixj_dialtone(j);
6444 break;
6445 case PHONE_BUSY:
6446 ixj_busytone(j);
6447 break;
6448 case PHONE_RINGBACK:
6449 ixj_ringback(j);
6450 break;
6451 case PHONE_WINK:
6452 if(j->cardtype == QTI_PHONEJACK)
6453 retval = -1;
6454 else
6455 retval = ixj_wink(j);
6456 break;
6457 case PHONE_CPT_STOP:
6458 ixj_cpt_stop(j);
6459 break;
6460 case PHONE_QUERY_CODEC:
6461 {
6462 struct phone_codec_data pd;
6463 int val;
6464 int proto_size[] = {
6465 -1,
6466 12, 10, 16, 9, 8, 48, 5,
6467 40, 40, 80, 40, 40, 6
6468 };
6469 if(copy_from_user(&pd, argp, sizeof(pd))) {
6470 retval = -EFAULT;
6471 break;
6472 }
6473 if(pd.type<1 || pd.type>13) {
6474 retval = -EPROTONOSUPPORT;
6475 break;
6476 }
6477 if(pd.type<G729)
6478 val=proto_size[pd.type];
6479 else switch(j->baseframe.low)
6480 {
6481 case 0xA0:val=2*proto_size[pd.type];break;
6482 case 0x50:val=proto_size[pd.type];break;
6483 default:val=proto_size[pd.type]*3;break;
6484 }
6485 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6486 if(copy_to_user(argp, &pd, sizeof(pd)))
6487 retval = -EFAULT;
6488 break;
6489 }
6490 case IXJCTL_DSP_IDLE:
6491 idle(j);
6492 break;
6493 case IXJCTL_MIXER:
6494 if ((arg & 0xff) == 0xff)
6495 retval = ixj_get_mixer(arg, j);
6496 else
6497 ixj_mixer(arg, j);
6498 break;
6499 case IXJCTL_DAA_COEFF_SET:
6500 switch (arg) {
6501 case DAA_US:
6502 DAA_Coeff_US(j);
6503 retval = ixj_daa_write(j);
6504 break;
6505 case DAA_UK:
6506 DAA_Coeff_UK(j);
6507 retval = ixj_daa_write(j);
6508 break;
6509 case DAA_FRANCE:
6510 DAA_Coeff_France(j);
6511 retval = ixj_daa_write(j);
6512 break;
6513 case DAA_GERMANY:
6514 DAA_Coeff_Germany(j);
6515 retval = ixj_daa_write(j);
6516 break;
6517 case DAA_AUSTRALIA:
6518 DAA_Coeff_Australia(j);
6519 retval = ixj_daa_write(j);
6520 break;
6521 case DAA_JAPAN:
6522 DAA_Coeff_Japan(j);
6523 retval = ixj_daa_write(j);
6524 break;
6525 default:
6526 retval = 1;
6527 break;
6528 }
6529 break;
6530 case IXJCTL_DAA_AGAIN:
6531 ixj_daa_cr4(j, arg | 0x02);
6532 break;
6533 case IXJCTL_PSTN_LINETEST:
6534 retval = ixj_linetest(j);
6535 break;
6536 case IXJCTL_VMWI:
6537 ixj_write_vmwi(j, arg);
6538 break;
6539 case IXJCTL_CID:
6540 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6541 retval = -EFAULT;
6542 j->ex.bits.caller_id = 0;
6543 break;
6544 case IXJCTL_WINK_DURATION:
6545 j->winktime = arg;
6546 break;
6547 case IXJCTL_PORT:
6548 if (arg)
6549 retval = ixj_set_port(j, arg);
6550 else
6551 retval = j->port;
6552 break;
6553 case IXJCTL_POTS_PSTN:
6554 retval = ixj_set_pots(j, arg);
6555 break;
6556 case PHONE_CAPABILITIES:
6557 add_caps(j);
6558 retval = j->caps;
6559 break;
6560 case PHONE_CAPABILITIES_LIST:
6561 add_caps(j);
6562 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6563 retval = -EFAULT;
6564 break;
6565 case PHONE_CAPABILITIES_CHECK:
6566 {
6567 struct phone_capability cap;
6568 if (copy_from_user(&cap, argp, sizeof(cap)))
6569 retval = -EFAULT;
6570 else {
6571 add_caps(j);
6572 retval = capabilities_check(j, &cap);
6573 }
6574 }
6575 break;
6576 case PHONE_PSTN_SET_STATE:
6577 daa_set_mode(j, arg);
6578 break;
6579 case PHONE_PSTN_GET_STATE:
6580 retval = j->daa_mode;
6581 j->ex.bits.pstn_ring = 0;
6582 break;
6583 case IXJCTL_SET_FILTER:
6584 if (copy_from_user(&jf, argp, sizeof(jf)))
6585 retval = -EFAULT;
6586 retval = ixj_init_filter(j, &jf);
6587 break;
6588 case IXJCTL_SET_FILTER_RAW:
6589 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6590 retval = -EFAULT;
6591 else
6592 retval = ixj_init_filter_raw(j, &jfr);
6593 break;
6594 case IXJCTL_GET_FILTER_HIST:
6595 if(arg<0||arg>3)
6596 retval = -EINVAL;
6597 else
6598 retval = j->filter_hist[arg];
6599 break;
6600 case IXJCTL_INIT_TONE:
6601 if (copy_from_user(&ti, argp, sizeof(ti)))
6602 retval = -EFAULT;
6603 else
6604 retval = ixj_init_tone(j, &ti);
6605 break;
6606 case IXJCTL_TONE_CADENCE:
6607 retval = ixj_build_cadence(j, argp);
6608 break;
6609 case IXJCTL_FILTER_CADENCE:
6610 retval = ixj_build_filter_cadence(j, argp);
6611 break;
6612 case IXJCTL_SIGCTL:
6613 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6614 retval = -EFAULT;
6615 break;
6616 }
6617 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6618 if(j->sigdef.event < 33) {
6619 raise = 1;
6620 for(mant = 0; mant < j->sigdef.event; mant++){
6621 raise *= 2;
6622 }
6623 if(j->sigdef.signal)
6624 j->ex_sig.bytes |= raise;
6625 else
6626 j->ex_sig.bytes &= (raise^0xffff);
6627 }
6628 break;
6629 case IXJCTL_INTERCOM_STOP:
6630 if(arg < 0 || arg >= IXJMAX)
6631 return -EINVAL;
6632 j->intercom = -1;
6633 ixj_record_stop(j);
6634 ixj_play_stop(j);
6635 idle(j);
6636 get_ixj(arg)->intercom = -1;
6637 ixj_record_stop(get_ixj(arg));
6638 ixj_play_stop(get_ixj(arg));
6639 idle(get_ixj(arg));
6640 break;
6641 case IXJCTL_INTERCOM_START:
6642 if(arg < 0 || arg >= IXJMAX)
6643 return -EINVAL;
6644 j->intercom = arg;
6645 ixj_record_start(j);
6646 ixj_play_start(j);
6647 get_ixj(arg)->intercom = board;
6648 ixj_play_start(get_ixj(arg));
6649 ixj_record_start(get_ixj(arg));
6650 break;
6651 }
6652 if (ixjdebug & 0x0040)
6653 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6654 clear_bit(board, &j->busyflags);
6655 return retval;
6656 }
6657
6658 static int ixj_fasync(int fd, struct file *file_p, int mode)
6659 {
6660 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6661
6662 return fasync_helper(fd, file_p, mode, &j->async_queue);
6663 }
6664
6665 static struct file_operations ixj_fops =
6666 {
6667 .owner = THIS_MODULE,
6668 .read = ixj_enhanced_read,
6669 .write = ixj_enhanced_write,
6670 .poll = ixj_poll,
6671 .ioctl = ixj_ioctl,
6672 .release = ixj_release,
6673 .fasync = ixj_fasync
6674 };
6675
6676 static int ixj_linetest(IXJ *j)
6677 {
6678 j->flags.pstncheck = 1; /* Testing */
6679 j->flags.pstn_present = 0; /* Assume the line is not there */
6680
6681 daa_int_read(j); /*Clear DAA Interrupt flags */
6682 /* */
6683 /* Hold all relays in the normally de-energized position. */
6684 /* */
6685
6686 j->pld_slicw.bits.rly1 = 0;
6687 j->pld_slicw.bits.rly2 = 0;
6688 j->pld_slicw.bits.rly3 = 0;
6689 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6690 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6691
6692 outb_p(j->pld_scrw.byte, j->XILINXbase);
6693 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6694 if (j->pld_slicr.bits.potspstn) {
6695 j->flags.pots_pstn = 1;
6696 j->flags.pots_correct = 0;
6697 LED_SetState(0x4, j);
6698 } else {
6699 j->flags.pots_pstn = 0;
6700 j->pld_slicw.bits.rly1 = 0;
6701 j->pld_slicw.bits.rly2 = 0;
6702 j->pld_slicw.bits.rly3 = 1;
6703 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6704 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6705
6706 outb_p(j->pld_scrw.byte, j->XILINXbase);
6707 daa_set_mode(j, SOP_PU_CONVERSATION);
6708 msleep(1000);
6709 daa_int_read(j);
6710 daa_set_mode(j, SOP_PU_RESET);
6711 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6712 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6713 LED_SetState(0x4, j);
6714 j->pld_slicw.bits.rly3 = 0;
6715 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6716 } else {
6717 j->flags.pots_correct = 1;
6718 LED_SetState(0x8, j);
6719 j->pld_slicw.bits.rly1 = 1;
6720 j->pld_slicw.bits.rly2 = 0;
6721 j->pld_slicw.bits.rly3 = 0;
6722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6723 }
6724 }
6725 j->pld_slicw.bits.rly3 = 0;
6726 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6727 daa_set_mode(j, SOP_PU_CONVERSATION);
6728 msleep(1000);
6729 daa_int_read(j);
6730 daa_set_mode(j, SOP_PU_RESET);
6731 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6732 j->pstn_sleeptil = jiffies + (hertz / 4);
6733 j->flags.pstn_present = 1;
6734 } else {
6735 j->flags.pstn_present = 0;
6736 }
6737 if (j->flags.pstn_present) {
6738 if (j->flags.pots_correct) {
6739 LED_SetState(0xA, j);
6740 } else {
6741 LED_SetState(0x6, j);
6742 }
6743 } else {
6744 if (j->flags.pots_correct) {
6745 LED_SetState(0x9, j);
6746 } else {
6747 LED_SetState(0x5, j);
6748 }
6749 }
6750 j->flags.pstncheck = 0; /* Testing */
6751 return j->flags.pstn_present;
6752 }
6753
6754 static int ixj_selfprobe(IXJ *j)
6755 {
6756 unsigned short cmd;
6757 int cnt;
6758 BYTES bytes;
6759
6760 init_waitqueue_head(&j->poll_q);
6761 init_waitqueue_head(&j->read_q);
6762 init_waitqueue_head(&j->write_q);
6763
6764 while(atomic_read(&j->DSPWrite) > 0)
6765 atomic_dec(&j->DSPWrite);
6766 if (ixjdebug & 0x0002)
6767 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6768 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6769
6770 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6771 return -1;
6772 /* The read values of the SSR should be 0x00 for the IDLE command */
6773 if (j->ssr.low || j->ssr.high)
6774 return -1;
6775 if (ixjdebug & 0x0002)
6776 printk(KERN_INFO "Get Device ID Code\n");
6777 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6778 return -1;
6779 j->dsp.low = j->ssr.low;
6780 j->dsp.high = j->ssr.high;
6781 if (ixjdebug & 0x0002)
6782 printk(KERN_INFO "Get Device Version Code\n");
6783 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6784 return -1;
6785 j->ver.low = j->ssr.low;
6786 j->ver.high = j->ssr.high;
6787 if (!j->cardtype) {
6788 if (j->dsp.low == 0x21) {
6789 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6790 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6791 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6792 bytes.low = inb_p(j->XILINXbase + 0x02);
6793 if (bytes.low == bytes.high) /* Register is read only on */
6794 /* Internet PhoneJack Lite */
6795 {
6796 j->cardtype = QTI_PHONEJACK_LITE;
6797 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6798 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6799 return -1;
6800 }
6801 j->pld_slicw.pcib.e1 = 1;
6802 outb_p(j->pld_slicw.byte, j->XILINXbase);
6803 } else {
6804 j->cardtype = QTI_LINEJACK;
6805
6806 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6807 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6808 return -1;
6809 }
6810 }
6811 } else if (j->dsp.low == 0x22) {
6812 j->cardtype = QTI_PHONEJACK_PCI;
6813 request_region(j->XILINXbase, 4, "ixj control");
6814 j->pld_slicw.pcib.e1 = 1;
6815 outb_p(j->pld_slicw.byte, j->XILINXbase);
6816 } else
6817 j->cardtype = QTI_PHONEJACK;
6818 } else {
6819 switch (j->cardtype) {
6820 case QTI_PHONEJACK:
6821 if (!j->dsp.low != 0x20) {
6822 j->dsp.high = 0x80;
6823 j->dsp.low = 0x20;
6824 ixj_WriteDSPCommand(0x3800, j);
6825 j->ver.low = j->ssr.low;
6826 j->ver.high = j->ssr.high;
6827 }
6828 break;
6829 case QTI_LINEJACK:
6830 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6831 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6832 return -1;
6833 }
6834 break;
6835 case QTI_PHONEJACK_LITE:
6836 case QTI_PHONEJACK_PCI:
6837 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6838 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6839 return -1;
6840 }
6841 j->pld_slicw.pcib.e1 = 1;
6842 outb_p(j->pld_slicw.byte, j->XILINXbase);
6843 break;
6844 case QTI_PHONECARD:
6845 break;
6846 }
6847 }
6848 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6849 if (ixjdebug & 0x0002)
6850 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6851 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6852 return -1;
6853 if (ixjdebug & 0x0002)
6854 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6855 if (j->cardtype == QTI_PHONEJACK) {
6856 cmd = 0x9FF2;
6857 } else {
6858 cmd = 0x9FF5;
6859 }
6860 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6861 return -1;
6862 } else {
6863 if (set_base_frame(j, 30) != 30)
6864 return -1;
6865 if (ixjdebug & 0x0002)
6866 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6867 if (j->cardtype == QTI_PHONECARD) {
6868 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6869 return -1;
6870 }
6871 if (j->cardtype == QTI_LINEJACK) {
6872 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6873 return -1;
6874 if (ixjdebug & 0x0002)
6875 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6876 j->pld_clock.byte = 0;
6877 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6878 }
6879 }
6880
6881 if (j->dsp.low == 0x20) {
6882 if (ixjdebug & 0x0002)
6883 printk(KERN_INFO "Configure GPIO pins\n");
6884 j->gpio.bytes.high = 0x09;
6885 /* bytes.low = 0xEF; 0xF7 */
6886 j->gpio.bits.gpio1 = 1;
6887 j->gpio.bits.gpio2 = 1;
6888 j->gpio.bits.gpio3 = 0;
6889 j->gpio.bits.gpio4 = 1;
6890 j->gpio.bits.gpio5 = 1;
6891 j->gpio.bits.gpio6 = 1;
6892 j->gpio.bits.gpio7 = 1;
6893 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6894 if (ixjdebug & 0x0002)
6895 printk(KERN_INFO "Enable SLIC\n");
6896 j->gpio.bytes.high = 0x0B;
6897 j->gpio.bytes.low = 0x00;
6898 j->gpio.bits.gpio1 = 0;
6899 j->gpio.bits.gpio2 = 1;
6900 j->gpio.bits.gpio5 = 0;
6901 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6902 j->port = PORT_POTS;
6903 } else {
6904 if (j->cardtype == QTI_LINEJACK) {
6905 LED_SetState(0x1, j);
6906 msleep(100);
6907 LED_SetState(0x2, j);
6908 msleep(100);
6909 LED_SetState(0x4, j);
6910 msleep(100);
6911 LED_SetState(0x8, j);
6912 msleep(100);
6913 LED_SetState(0x0, j);
6914 daa_get_version(j);
6915 if (ixjdebug & 0x0002)
6916 printk("Loading DAA Coefficients\n");
6917 DAA_Coeff_US(j);
6918 if (!ixj_daa_write(j)) {
6919 printk("DAA write failed on board %d\n", j->board);
6920 return -1;
6921 }
6922 if(!ixj_daa_cid_reset(j)) {
6923 printk("DAA CID reset failed on board %d\n", j->board);
6924 return -1;
6925 }
6926 j->flags.pots_correct = 0;
6927 j->flags.pstn_present = 0;
6928 ixj_linetest(j);
6929 if (j->flags.pots_correct) {
6930 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6931
6932 outb_p(j->pld_scrw.byte, j->XILINXbase);
6933 j->pld_slicw.bits.rly1 = 1;
6934 j->pld_slicw.bits.spken = 1;
6935 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6936 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6937 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6938 j->port = PORT_POTS;
6939 }
6940 ixj_set_port(j, PORT_PSTN);
6941 ixj_set_pots(j, 1);
6942 if (ixjdebug & 0x0002)
6943 printk(KERN_INFO "Enable Mixer\n");
6944 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6945 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6946
6947 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6948 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6949
6950 ixj_mixer(0x0480, j); /*FM Left mute */
6951 ixj_mixer(0x0580, j); /*FM Right mute */
6952
6953 ixj_mixer(0x0680, j); /*CD Left mute */
6954 ixj_mixer(0x0780, j); /*CD Right mute */
6955
6956 ixj_mixer(0x0880, j); /*Line Left mute */
6957 ixj_mixer(0x0980, j); /*Line Right mute */
6958
6959 ixj_mixer(0x0A80, j); /*Aux left mute */
6960 ixj_mixer(0x0B80, j); /*Aux right mute */
6961
6962 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6963 ixj_mixer(0x0D80, j); /*Mono2 mute */
6964
6965 ixj_mixer(0x0E80, j); /*Mic mute */
6966
6967 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6968
6969 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6970 ixj_mixer(0x110C, j);
6971
6972
6973 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6974 ixj_mixer(0x1401, j);
6975
6976 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6977 ixj_mixer(0x1501, j);
6978
6979 ixj_mixer(0x1700, j); /*Clock select */
6980
6981 ixj_mixer(0x1800, j); /*ADC input from mixer */
6982
6983 ixj_mixer(0x1901, j); /*Mic gain 30db */
6984
6985 if (ixjdebug & 0x0002)
6986 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6987 j->cadence_f[4].state = 0;
6988 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6989 j->cadence_f[4].off1 = 0;
6990 j->cadence_f[4].on2 = 0;
6991 j->cadence_f[4].off2 = 0;
6992 j->cadence_f[4].on3 = 0;
6993 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
6994 j->pstn_last_rmr = jiffies;
6995
6996 } else {
6997 if (j->cardtype == QTI_PHONECARD) {
6998 ixj_WriteDSPCommand(0xCF07, j);
6999 ixj_WriteDSPCommand(0x00B0, j);
7000 ixj_set_port(j, PORT_SPEAKER);
7001 } else {
7002 ixj_set_port(j, PORT_POTS);
7003 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7004 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7005 }
7006 }
7007 }
7008
7009 j->intercom = -1;
7010 j->framesread = j->frameswritten = 0;
7011 j->read_wait = j->write_wait = 0;
7012 j->rxreadycheck = j->txreadycheck = 0;
7013
7014 /* initialise the DTMF prescale to a sensible value */
7015 if (j->cardtype == QTI_LINEJACK) {
7016 set_dtmf_prescale(j, 0x10);
7017 } else {
7018 set_dtmf_prescale(j, 0x40);
7019 }
7020 set_play_volume(j, 0x100);
7021 set_rec_volume(j, 0x100);
7022
7023 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7024 return -1;
7025 /* The read values of the SSR should be 0x00 for the IDLE command */
7026 if (j->ssr.low || j->ssr.high)
7027 return -1;
7028
7029 if (ixjdebug & 0x0002)
7030 printk(KERN_INFO "Enable Line Monitor\n");
7031
7032 if (ixjdebug & 0x0002)
7033 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7034
7035 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7036 return -1;
7037
7038 if (ixjdebug & 0x002)
7039 printk(KERN_INFO "Enable DTMF Detectors\n");
7040
7041 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7042 return -1;
7043
7044 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7045 return -1;
7046
7047 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7048
7049 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7050
7051 j->ex.bits.dtmf_ready = 0;
7052 j->dtmf_state = 0;
7053 j->dtmf_wp = j->dtmf_rp = 0;
7054 j->rec_mode = j->play_mode = -1;
7055 j->flags.ringing = 0;
7056 j->maxrings = MAXRINGS;
7057 j->ring_cadence = USA_RING_CADENCE;
7058 j->drybuffer = 0;
7059 j->winktime = 320;
7060 j->flags.dtmf_oob = 0;
7061 for (cnt = 0; cnt < 4; cnt++)
7062 j->cadence_f[cnt].enable = 0;
7063 /* must be a device on the specified address */
7064 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7065
7066 /* Set up the default signals for events */
7067 for (cnt = 0; cnt < 35; cnt++)
7068 j->ixj_signals[cnt] = SIGIO;
7069
7070 /* Set the excetion signal enable flags */
7071 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7072 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 =
7073 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;
7074 #ifdef IXJ_DYN_ALLOC
7075 j->fskdata = NULL;
7076 #endif
7077 j->fskdcnt = 0;
7078 j->cidcw_wait = 0;
7079
7080 /* Register with the Telephony for Linux subsystem */
7081 j->p.f_op = &ixj_fops;
7082 j->p.open = ixj_open;
7083 j->p.board = j->board;
7084 phone_register_device(&j->p, PHONE_UNIT_ANY);
7085
7086 ixj_init_timer(j);
7087 ixj_add_timer(j);
7088 return 0;
7089 }
7090
7091 /*
7092 * Exported service for pcmcia card handling
7093 */
7094
7095 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7096 {
7097 IXJ *j = ixj_alloc();
7098
7099 j->board = 0;
7100
7101 j->DSPbase = dsp;
7102 j->XILINXbase = xilinx;
7103 j->cardtype = QTI_PHONECARD;
7104 ixj_selfprobe(j);
7105 return j;
7106 }
7107
7108 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7109
7110 static int ixj_get_status_proc(char *buf)
7111 {
7112 int len;
7113 int cnt;
7114 IXJ *j;
7115 len = 0;
7116 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7117 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7118 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7119 len += sprintf(buf + len, "\nUsing old telephony API");
7120 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7121
7122 for (cnt = 0; cnt < IXJMAX; cnt++) {
7123 j = get_ixj(cnt);
7124 if(j==NULL)
7125 continue;
7126 if (j->DSPbase) {
7127 len += sprintf(buf + len, "\nCard Num %d", cnt);
7128 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7129 if (j->cardtype != QTI_PHONEJACK)
7130 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7131 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7132 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7133 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7134 switch (j->cardtype) {
7135 case (QTI_PHONEJACK):
7136 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7137 break;
7138 case (QTI_LINEJACK):
7139 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7140 if (j->flags.g729_loaded)
7141 len += sprintf(buf + len, " w/G.729 A/B");
7142 len += sprintf(buf + len, " Country = %d", j->daa_country);
7143 break;
7144 case (QTI_PHONEJACK_LITE):
7145 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7146 if (j->flags.g729_loaded)
7147 len += sprintf(buf + len, " w/G.729 A/B");
7148 break;
7149 case (QTI_PHONEJACK_PCI):
7150 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7151 if (j->flags.g729_loaded)
7152 len += sprintf(buf + len, " w/G.729 A/B");
7153 break;
7154 case (QTI_PHONECARD):
7155 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7156 if (j->flags.g729_loaded)
7157 len += sprintf(buf + len, " w/G.729 A/B");
7158 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7159 if (!j->pccr1.bits.drf)
7160 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7161 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7162 break;
7163 default:
7164 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7165 break;
7166 }
7167 len += sprintf(buf + len, "\nReaders %d", j->readers);
7168 len += sprintf(buf + len, "\nWriters %d", j->writers);
7169 add_caps(j);
7170 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7171 if (j->dsp.low != 0x20)
7172 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7173 if (j->flags.cidsent)
7174 len += sprintf(buf + len, "\nCaller ID data sent");
7175 else
7176 len += sprintf(buf + len, "\nCaller ID data not sent");
7177
7178 len += sprintf(buf + len, "\nPlay CODEC ");
7179 switch (j->play_codec) {
7180 case G723_63:
7181 len += sprintf(buf + len, "G.723.1 6.3");
7182 break;
7183 case G723_53:
7184 len += sprintf(buf + len, "G.723.1 5.3");
7185 break;
7186 case TS85:
7187 len += sprintf(buf + len, "TrueSpeech 8.5");
7188 break;
7189 case TS48:
7190 len += sprintf(buf + len, "TrueSpeech 4.8");
7191 break;
7192 case TS41:
7193 len += sprintf(buf + len, "TrueSpeech 4.1");
7194 break;
7195 case G728:
7196 len += sprintf(buf + len, "G.728");
7197 break;
7198 case G729:
7199 len += sprintf(buf + len, "G.729");
7200 break;
7201 case G729B:
7202 len += sprintf(buf + len, "G.729B");
7203 break;
7204 case ULAW:
7205 len += sprintf(buf + len, "uLaw");
7206 break;
7207 case ALAW:
7208 len += sprintf(buf + len, "aLaw");
7209 break;
7210 case LINEAR16:
7211 len += sprintf(buf + len, "16 bit Linear");
7212 break;
7213 case LINEAR8:
7214 len += sprintf(buf + len, "8 bit Linear");
7215 break;
7216 case WSS:
7217 len += sprintf(buf + len, "Windows Sound System");
7218 break;
7219 default:
7220 len += sprintf(buf + len, "NO CODEC CHOSEN");
7221 break;
7222 }
7223 len += sprintf(buf + len, "\nRecord CODEC ");
7224 switch (j->rec_codec) {
7225 case G723_63:
7226 len += sprintf(buf + len, "G.723.1 6.3");
7227 break;
7228 case G723_53:
7229 len += sprintf(buf + len, "G.723.1 5.3");
7230 break;
7231 case TS85:
7232 len += sprintf(buf + len, "TrueSpeech 8.5");
7233 break;
7234 case TS48:
7235 len += sprintf(buf + len, "TrueSpeech 4.8");
7236 break;
7237 case TS41:
7238 len += sprintf(buf + len, "TrueSpeech 4.1");
7239 break;
7240 case G728:
7241 len += sprintf(buf + len, "G.728");
7242 break;
7243 case G729:
7244 len += sprintf(buf + len, "G.729");
7245 break;
7246 case G729B:
7247 len += sprintf(buf + len, "G.729B");
7248 break;
7249 case ULAW:
7250 len += sprintf(buf + len, "uLaw");
7251 break;
7252 case ALAW:
7253 len += sprintf(buf + len, "aLaw");
7254 break;
7255 case LINEAR16:
7256 len += sprintf(buf + len, "16 bit Linear");
7257 break;
7258 case LINEAR8:
7259 len += sprintf(buf + len, "8 bit Linear");
7260 break;
7261 case WSS:
7262 len += sprintf(buf + len, "Windows Sound System");
7263 break;
7264 default:
7265 len += sprintf(buf + len, "NO CODEC CHOSEN");
7266 break;
7267 }
7268 len += sprintf(buf + len, "\nAEC ");
7269 switch (j->aec_level) {
7270 case AEC_OFF:
7271 len += sprintf(buf + len, "Off");
7272 break;
7273 case AEC_LOW:
7274 len += sprintf(buf + len, "Low");
7275 break;
7276 case AEC_MED:
7277 len += sprintf(buf + len, "Med");
7278 break;
7279 case AEC_HIGH:
7280 len += sprintf(buf + len, "High");
7281 break;
7282 case AEC_AUTO:
7283 len += sprintf(buf + len, "Auto");
7284 break;
7285 case AEC_AGC:
7286 len += sprintf(buf + len, "AEC/AGC");
7287 break;
7288 default:
7289 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7290 break;
7291 }
7292
7293 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7294 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7295 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7296
7297 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7298
7299 if (j->cardtype == QTI_LINEJACK) {
7300 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7301 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7302 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7303 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7304 switch (j->daa_mode) {
7305 case SOP_PU_SLEEP:
7306 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7307 break;
7308 case SOP_PU_RINGING:
7309 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7310 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7311 break;
7312 case SOP_PU_CONVERSATION:
7313 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7314 break;
7315 case SOP_PU_PULSEDIALING:
7316 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7317 break;
7318 }
7319 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7320 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7321 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7322 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7323 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7324 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7325 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7326 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7327 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7328 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7329 }
7330 switch (j->port) {
7331 case PORT_POTS:
7332 len += sprintf(buf + len, "\nPort POTS");
7333 break;
7334 case PORT_PSTN:
7335 len += sprintf(buf + len, "\nPort PSTN");
7336 break;
7337 case PORT_SPEAKER:
7338 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7339 break;
7340 case PORT_HANDSET:
7341 len += sprintf(buf + len, "\nPort HANDSET");
7342 break;
7343 }
7344 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7345 len += sprintf(buf + len, "\nSLIC state ");
7346 switch (SLIC_GetState(j)) {
7347 case PLD_SLIC_STATE_OC:
7348 len += sprintf(buf + len, "OC");
7349 break;
7350 case PLD_SLIC_STATE_RINGING:
7351 len += sprintf(buf + len, "RINGING");
7352 break;
7353 case PLD_SLIC_STATE_ACTIVE:
7354 len += sprintf(buf + len, "ACTIVE");
7355 break;
7356 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7357 len += sprintf(buf + len, "OHT");
7358 break;
7359 case PLD_SLIC_STATE_TIPOPEN:
7360 len += sprintf(buf + len, "TIPOPEN");
7361 break;
7362 case PLD_SLIC_STATE_STANDBY:
7363 len += sprintf(buf + len, "STANDBY");
7364 break;
7365 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7366 len += sprintf(buf + len, "APR");
7367 break;
7368 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7369 len += sprintf(buf + len, "OHTPR");
7370 break;
7371 default:
7372 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7373 break;
7374 }
7375 }
7376 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7377 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7378 #ifdef PERFMON_STATS
7379 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7380 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7381 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7382 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7383 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7384 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7385 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7386 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7387 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7388 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7389 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7390 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7391 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7392 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7393
7394 #endif
7395 len += sprintf(buf + len, "\n");
7396 }
7397 }
7398 return len;
7399 }
7400
7401 static int ixj_read_proc(char *page, char **start, off_t off,
7402 int count, int *eof, void *data)
7403 {
7404 int len = ixj_get_status_proc(page);
7405 if (len <= off+count) *eof = 1;
7406 *start = page + off;
7407 len -= off;
7408 if (len>count) len = count;
7409 if (len<0) len = 0;
7410 return len;
7411 }
7412
7413
7414 static void cleanup(void)
7415 {
7416 int cnt;
7417 IXJ *j;
7418
7419 for (cnt = 0; cnt < IXJMAX; cnt++) {
7420 j = get_ixj(cnt);
7421 if(j != NULL && j->DSPbase) {
7422 if (ixjdebug & 0x0002)
7423 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7424 del_timer(&j->timer);
7425 if (j->cardtype == QTI_LINEJACK) {
7426 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7427
7428 outb_p(j->pld_scrw.byte, j->XILINXbase);
7429 j->pld_slicw.bits.rly1 = 0;
7430 j->pld_slicw.bits.rly2 = 0;
7431 j->pld_slicw.bits.rly3 = 0;
7432 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7433 LED_SetState(0x0, j);
7434 if (ixjdebug & 0x0002)
7435 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7436 release_region(j->XILINXbase, 8);
7437 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7438 if (ixjdebug & 0x0002)
7439 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7440 release_region(j->XILINXbase, 4);
7441 }
7442 kfree(j->read_buffer);
7443 kfree(j->write_buffer);
7444 if (j->dev)
7445 pnp_device_detach(j->dev);
7446 if (ixjdebug & 0x0002)
7447 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7448 phone_unregister_device(&j->p);
7449 if (ixjdebug & 0x0002)
7450 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7451 release_region(j->DSPbase, 16);
7452 #ifdef IXJ_DYN_ALLOC
7453 if (ixjdebug & 0x0002)
7454 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7455 kfree(j);
7456 ixj[cnt] = NULL;
7457 #endif
7458 }
7459 }
7460 if (ixjdebug & 0x0002)
7461 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7462 remove_proc_entry ("ixj", NULL);
7463 }
7464
7465 /* Typedefs */
7466 typedef struct {
7467 BYTE length;
7468 DWORD bits;
7469 } DATABLOCK;
7470
7471 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7472 {
7473 lastLCC = lastLCC & 0xfb;
7474 lastLCC = lastLCC | (byData ? 4 : 0);
7475 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7476
7477 mdelay(1);
7478 lastLCC = lastLCC | 0x01;
7479 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7480
7481 byData = byData << 1;
7482 lastLCC = lastLCC & 0xfe;
7483 mdelay(1);
7484 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7485
7486 }
7487
7488 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7489 {
7490 mdelay(1);
7491 lastLCC = lastLCC | 0x01;
7492 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7493
7494 lastLCC = lastLCC & 0xfe;
7495 mdelay(1);
7496 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7497
7498 return ((inb(wEEPROMAddress) >> 3) & 1);
7499 }
7500
7501 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7502 {
7503 BYTE lastLCC;
7504 WORD wEEPROMAddress = wAddress + 3;
7505 DWORD i;
7506 BYTE byResult;
7507 *pwResult = 0;
7508 lastLCC = inb(wEEPROMAddress);
7509 lastLCC = lastLCC | 0x02;
7510 lastLCC = lastLCC & 0xfe;
7511 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7512
7513 mdelay(1); /* delay */
7514
7515 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7516 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7517 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7518 for (i = 0; i < 8; i++) {
7519 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7520 wLoc <<= 1;
7521 }
7522
7523 for (i = 0; i < 16; i++) {
7524 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7525 *pwResult = (*pwResult << 1) | byResult;
7526 }
7527
7528 mdelay(1); /* another delay */
7529
7530 lastLCC = lastLCC & 0xfd;
7531 outb(lastLCC, wEEPROMAddress); /* negate CS */
7532
7533 return 0;
7534 }
7535
7536 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7537 {
7538 WORD wLo, wHi;
7539 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7540 return 0;
7541 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7542 return 0;
7543 return (((DWORD) wHi << 16) | wLo);
7544 }
7545
7546 static int dspio[IXJMAX + 1] =
7547 {
7548 0,
7549 };
7550 static int xio[IXJMAX + 1] =
7551 {
7552 0,
7553 };
7554
7555 module_param_array(dspio, int, NULL, 0);
7556 module_param_array(xio, int, NULL, 0);
7557 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7558 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7559 MODULE_LICENSE("GPL");
7560
7561 static void __exit ixj_exit(void)
7562 {
7563 cleanup();
7564 }
7565
7566 static IXJ *new_ixj(unsigned long port)
7567 {
7568 IXJ *res;
7569 if (!request_region(port, 16, "ixj DSP")) {
7570 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7571 return NULL;
7572 }
7573 res = ixj_alloc();
7574 if (!res) {
7575 release_region(port, 16);
7576 printk(KERN_INFO "ixj: out of memory\n");
7577 return NULL;
7578 }
7579 res->DSPbase = port;
7580 return res;
7581 }
7582
7583 static int __init ixj_probe_isapnp(int *cnt)
7584 {
7585 int probe = 0;
7586 int func = 0x110;
7587 struct pnp_dev *dev = NULL, *old_dev = NULL;
7588
7589 while (1) {
7590 do {
7591 IXJ *j;
7592 int result;
7593
7594 old_dev = dev;
7595 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7596 ISAPNP_FUNCTION(func), old_dev);
7597 if (!dev || !dev->card)
7598 break;
7599 result = pnp_device_attach(dev);
7600 if (result < 0) {
7601 printk("pnp attach failed %d \n", result);
7602 break;
7603 }
7604 if (pnp_activate_dev(dev) < 0) {
7605 printk("pnp activate failed (out of resources?)\n");
7606 pnp_device_detach(dev);
7607 return -ENOMEM;
7608 }
7609
7610 if (!pnp_port_valid(dev, 0)) {
7611 pnp_device_detach(dev);
7612 return -ENODEV;
7613 }
7614
7615 j = new_ixj(pnp_port_start(dev, 0));
7616 if (!j)
7617 break;
7618
7619 if (func != 0x110)
7620 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7621
7622 switch (func) {
7623 case (0x110):
7624 j->cardtype = QTI_PHONEJACK;
7625 break;
7626 case (0x310):
7627 j->cardtype = QTI_LINEJACK;
7628 break;
7629 case (0x410):
7630 j->cardtype = QTI_PHONEJACK_LITE;
7631 break;
7632 }
7633 j->board = *cnt;
7634 probe = ixj_selfprobe(j);
7635 if(!probe) {
7636 j->serial = dev->card->serial;
7637 j->dev = dev;
7638 switch (func) {
7639 case 0x110:
7640 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7641 break;
7642 case 0x310:
7643 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7644 break;
7645 case 0x410:
7646 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7647 break;
7648 }
7649 }
7650 ++*cnt;
7651 } while (dev);
7652 if (func == 0x410)
7653 break;
7654 if (func == 0x310)
7655 func = 0x410;
7656 if (func == 0x110)
7657 func = 0x310;
7658 dev = NULL;
7659 }
7660 return probe;
7661 }
7662
7663 static int __init ixj_probe_isa(int *cnt)
7664 {
7665 int i, probe;
7666
7667 /* Use passed parameters for older kernels without PnP */
7668 for (i = 0; i < IXJMAX; i++) {
7669 if (dspio[i]) {
7670 IXJ *j = new_ixj(dspio[i]);
7671
7672 if (!j)
7673 break;
7674
7675 j->XILINXbase = xio[i];
7676 j->cardtype = 0;
7677
7678 j->board = *cnt;
7679 probe = ixj_selfprobe(j);
7680 j->dev = NULL;
7681 ++*cnt;
7682 }
7683 }
7684 return 0;
7685 }
7686
7687 static int __init ixj_probe_pci(int *cnt)
7688 {
7689 struct pci_dev *pci = NULL;
7690 int i, probe = 0;
7691 IXJ *j = NULL;
7692
7693 for (i = 0; i < IXJMAX - *cnt; i++) {
7694 pci = pci_find_device(PCI_VENDOR_ID_QUICKNET,
7695 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7696 if (!pci)
7697 break;
7698
7699 if (pci_enable_device(pci))
7700 break;
7701 j = new_ixj(pci_resource_start(pci, 0));
7702 if (!j)
7703 break;
7704
7705 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7706 j->XILINXbase = j->DSPbase + 0x10;
7707 j->cardtype = QTI_PHONEJACK_PCI;
7708 j->board = *cnt;
7709 probe = ixj_selfprobe(j);
7710 if (!probe)
7711 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7712 ++*cnt;
7713 }
7714 return probe;
7715 }
7716
7717 static int __init ixj_init(void)
7718 {
7719 int cnt = 0;
7720 int probe = 0;
7721
7722 cnt = 0;
7723
7724 /* These might be no-ops, see above. */
7725 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7726 return probe;
7727 }
7728 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7729 return probe;
7730 }
7731 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7732 return probe;
7733 }
7734 printk(KERN_INFO "ixj driver initialized.\n");
7735 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7736 return probe;
7737 }
7738
7739 module_init(ixj_init);
7740 module_exit(ixj_exit);
7741
7742 static void DAA_Coeff_US(IXJ *j)
7743 {
7744 int i;
7745
7746 j->daa_country = DAA_US;
7747 /*----------------------------------------------- */
7748 /* CAO */
7749 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7750 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7751 }
7752
7753 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7754 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7755 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7756 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7757 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7758 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7759 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7760 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7761 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7762 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7771 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7772 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7773 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7774 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7775 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7776 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7777 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7778 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7779 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7780 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7789 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7790 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7791 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7792 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7793 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7794 /* Bytes for AR-filter (09): 52,D3,11,42 */
7795 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7796 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7797 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7798 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7799 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7800 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7801 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7802 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7803 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7804 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7805 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7806 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7807 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7808 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7817 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7826 /* ; (10K, 0.68uF) */
7827 /* */
7828 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7829 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7830 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7831 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7832 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7833 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7834 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7835 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7836 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7837 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7846
7847 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7848 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7849 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7850 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7851 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7852
7853 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7854 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7855 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7856 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7857 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7858 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7859 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7860 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7861 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7862 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7863 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7864 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7865 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7866 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7867 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7868 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7869 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7870 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7871 /* */
7872 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7876 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7877
7878 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7879 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7880 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7881 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7882 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7883 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7884 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7885 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7886 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7887 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7896 /* */
7897 /* ;CR Registers */
7898 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7899 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7900 /* Config. Reg. 1 (dialing) (cr1):05 */
7901 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7902 /* Config. Reg. 2 (caller ID) (cr2):04 */
7903 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7904 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7905 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7906 /* Config. Reg. 4 (analog gain) (cr4):02 */
7907 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7908 /* Config. Reg. 5 (Version) (cr5):02 */
7909 /* Config. Reg. 6 (Reserved) (cr6):00 */
7910 /* Config. Reg. 7 (Reserved) (cr7):00 */
7911 /* */
7912 /* ;xr Registers */
7913 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7914
7915 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7916 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7917
7918 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7919 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7920 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7921 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7922 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7923 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7924
7925 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7926 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7927 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7928 /* Ext. Reg. 6 (Power State) (xr6):00 */
7929 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7930 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7931 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7932 /* */
7933 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7934 /* 12,33,5A,C3 ; 770 Hz */
7935 /* 13,3C,5B,32 ; 852 Hz */
7936 /* 1D,1B,5C,CC ; 941 Hz */
7937
7938 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7939 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7940 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7941 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7942 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7943 /* EC,1D,52,22 ; 1336 Hz */
7944 /* AA,AC,51,D2 ; 1477 Hz */
7945 /* 9B,3B,51,25 ; 1633 Hz */
7946 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7947 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7950 }
7951
7952 static void DAA_Coeff_UK(IXJ *j)
7953 {
7954 int i;
7955
7956 j->daa_country = DAA_UK;
7957 /*----------------------------------------------- */
7958 /* CAO */
7959 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7960 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7961 }
7962
7963 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7964 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7965 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7966 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7967 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7968 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7969 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7970 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7971 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7972 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7981 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7982 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7983 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7984 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7985 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7986 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7987 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7988 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7989 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7990 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7999 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8000 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8001 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8002 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8003 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8004 /* Bytes for AR-filter (09): E2,27,10,D6 */
8005 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8006 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8007 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8008 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8009 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8010 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8011 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8012 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8013 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8014 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8015 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8016 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8017 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8018 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8027 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8036 /* ; idle */
8037 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8038 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8039 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8040 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8041 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8042 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8043 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8044 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8045 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8046 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8055 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8056 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8057 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8058 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8059 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8060 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8061 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8062 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8063 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8064 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8065 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8066 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8067 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8068 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8069 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8078 /* ;CR Registers */
8079 /* Config. Reg. 0 (filters) (cr0):FF */
8080 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8081 /* Config. Reg. 1 (dialing) (cr1):05 */
8082 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8083 /* Config. Reg. 2 (caller ID) (cr2):04 */
8084 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8085 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8086 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8087 /* Config. Reg. 4 (analog gain) (cr4):02 */
8088 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8089 /* Config. Reg. 5 (Version) (cr5):02 */
8090 /* Config. Reg. 6 (Reserved) (cr6):00 */
8091 /* Config. Reg. 7 (Reserved) (cr7):00 */
8092 /* ;xr Registers */
8093 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8094
8095 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8096 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8097
8098 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8099 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8100
8101 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8102 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8103 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8104 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8105 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8106 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8107 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8108 /* Ext. Reg. 6 (Power State) (xr6):00 */
8109 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8110 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8111 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8112 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8113 /* 12,33,5A,C3 ; 770 Hz */
8114 /* 13,3C,5B,32 ; 852 Hz */
8115 /* 1D,1B,5C,CC ; 941 Hz */
8116
8117 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8118 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8119 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8120 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8121 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8122 /* EC,1D,52,22 ; 1336 Hz */
8123 /* AA,AC,51,D2 ; 1477 Hz */
8124 /* 9B,3B,51,25 ; 1633 Hz */
8125 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8126 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8129 }
8130
8131
8132 static void DAA_Coeff_France(IXJ *j)
8133 {
8134 int i;
8135
8136 j->daa_country = DAA_FRANCE;
8137 /*----------------------------------------------- */
8138 /* CAO */
8139 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8140 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8141 }
8142
8143 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8144 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8145 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8146 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8147 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8148 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8149 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8150 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8151 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8152 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8161 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8162 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8163 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8164 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8165 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8166 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8167 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8168 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8169 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8170 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8179 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8180 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8181 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8182 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8183 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8184 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8185 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8186 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8187 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8188 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8189 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8190 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8191 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8192 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8193 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8194 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8195 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8196 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8197 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8198 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8207 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8216 /* ; idle */
8217 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8218 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8219 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8220 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8221 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8222 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8223 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8224 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8225 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8226 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8235 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8236 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8237 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8238 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8239 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8240 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8241 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8242 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8243 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8244 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8245 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8246 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8247 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8248 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8249 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8258 /* ;CR Registers */
8259 /* Config. Reg. 0 (filters) (cr0):FF */
8260 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8261 /* Config. Reg. 1 (dialing) (cr1):05 */
8262 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8263 /* Config. Reg. 2 (caller ID) (cr2):04 */
8264 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8265 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8266 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8267 /* Config. Reg. 4 (analog gain) (cr4):02 */
8268 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8269 /* Config. Reg. 5 (Version) (cr5):02 */
8270 /* Config. Reg. 6 (Reserved) (cr6):00 */
8271 /* Config. Reg. 7 (Reserved) (cr7):00 */
8272 /* ;xr Registers */
8273 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8274
8275 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8276 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8277
8278 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8279 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8280
8281 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8282 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8283 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8284 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8285 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8286 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8287 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8288 /* Ext. Reg. 6 (Power State) (xr6):00 */
8289 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8290 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8291 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8292 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8293 /* 12,33,5A,C3 ; 770 Hz */
8294 /* 13,3C,5B,32 ; 852 Hz */
8295 /* 1D,1B,5C,CC ; 941 Hz */
8296
8297 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8298 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8299 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8300 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8301 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8302 /* EC,1D,52,22 ; 1336 Hz */
8303 /* AA,AC,51,D2 ; 1477 Hz */
8304 /* 9B,3B,51,25 ; 1633 Hz */
8305 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8306 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8309 }
8310
8311
8312 static void DAA_Coeff_Germany(IXJ *j)
8313 {
8314 int i;
8315
8316 j->daa_country = DAA_GERMANY;
8317 /*----------------------------------------------- */
8318 /* CAO */
8319 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8320 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8321 }
8322
8323 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8324 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8325 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8326 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8327 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8328 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8329 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8330 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8331 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8332 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8341 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8342 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8343 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8344 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8345 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8346 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8347 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8348 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8349 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8350 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8359 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8360 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8361 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8362 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8363 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8364 /* Bytes for AR-filter (09): 72,42,13,4B */
8365 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8366 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8367 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8368 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8369 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8370 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8371 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8372 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8373 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8374 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8375 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8376 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8377 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8378 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8387 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8396 /* ; (10K, 0.68uF) */
8397 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8398 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8399 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8400 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8401 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8402 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8403 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8404 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8405 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8406 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8415 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8416 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8417 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8418 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8419 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8420 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8421 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8422 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8423 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8424 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8425 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8426 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8427 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8428 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8429 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8438 /* ;CR Registers */
8439 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8440 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8441 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8442 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8443 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8444 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8445 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8446 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8447 /* Config. Reg. 4 (analog gain) (cr4):02 */
8448 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8449 /* Config. Reg. 5 (Version) (cr5):02 */
8450 /* Config. Reg. 6 (Reserved) (cr6):00 */
8451 /* Config. Reg. 7 (Reserved) (cr7):00 */
8452 /* ;xr Registers */
8453 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8454
8455 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8456 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8457
8458 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8459 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8460
8461 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8462 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8463 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8464 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8465 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8466 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8467 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8468 /* Ext. Reg. 6 (Power State) (xr6):00 */
8469 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8470 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8471 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8472 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8473 /* 12,33,5A,C3 ; 770 Hz */
8474 /* 13,3C,5B,32 ; 852 Hz */
8475 /* 1D,1B,5C,CC ; 941 Hz */
8476
8477 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8478 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8479 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8480 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8481 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8482 /* EC,1D,52,22 ; 1336 Hz */
8483 /* AA,AC,51,D2 ; 1477 Hz */
8484 /* 9B,3B,51,25 ; 1633 Hz */
8485 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8486 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8489 }
8490
8491
8492 static void DAA_Coeff_Australia(IXJ *j)
8493 {
8494 int i;
8495
8496 j->daa_country = DAA_AUSTRALIA;
8497 /*----------------------------------------------- */
8498 /* CAO */
8499 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8500 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8501 }
8502
8503 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8504 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8505 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8506 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8507 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8508 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8509 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8510 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8511 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8512 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8521 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8522 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8523 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8524 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8525 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8526 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8527 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8528 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8529 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8530 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8539 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8540 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8541 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8542 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8543 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8544 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8545 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8546 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8547 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8548 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8549 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8550 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8551 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8552 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8553 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8554 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8555 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8556 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8557 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8558 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8567 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8576 /* ; idle */
8577 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8578 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8579 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8580 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8581 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8582 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8583 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8584 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8585 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8586 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8595 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8596 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8597 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8598 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8599 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8600 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8601 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8602 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8603 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8604 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8605 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8606 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8607 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8608 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8609 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8618 /* ;CR Registers */
8619 /* Config. Reg. 0 (filters) (cr0):FF */
8620 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8621 /* Config. Reg. 1 (dialing) (cr1):05 */
8622 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8623 /* Config. Reg. 2 (caller ID) (cr2):04 */
8624 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8625 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8626 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8627 /* Config. Reg. 4 (analog gain) (cr4):02 */
8628 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8629 /* Config. Reg. 5 (Version) (cr5):02 */
8630 /* Config. Reg. 6 (Reserved) (cr6):00 */
8631 /* Config. Reg. 7 (Reserved) (cr7):00 */
8632 /* ;xr Registers */
8633 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8634
8635 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8636 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8637
8638 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8639 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8640
8641 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8642 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8643 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8644 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8645 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8646 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8647 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8648 /* Ext. Reg. 6 (Power State) (xr6):00 */
8649 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8650 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8651 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8652
8653 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8654 /* 12,33,5A,C3 ; 770 Hz */
8655 /* 13,3C,5B,32 ; 852 Hz */
8656 /* 1D,1B,5C,CC ; 941 Hz */
8657 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8658 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8659 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8660 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8661
8662 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8663 /* EC,1D,52,22 ; 1336 Hz */
8664 /* AA,AC,51,D2 ; 1477 Hz */
8665 /* 9B,3B,51,25 ; 1633 Hz */
8666 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8668 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8669 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8670 }
8671
8672 static void DAA_Coeff_Japan(IXJ *j)
8673 {
8674 int i;
8675
8676 j->daa_country = DAA_JAPAN;
8677 /*----------------------------------------------- */
8678 /* CAO */
8679 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8680 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8681 }
8682
8683 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8684 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8685 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8686 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8687 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8688 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8689 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8690 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8691 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8692 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8701 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8702 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8703 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8704 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8705 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8706 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8707 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8708 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8709 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8710 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8719 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8720 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8721 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8722 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8723 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8724 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8725 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8726 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8727 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8728 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8729 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8730 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8731 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8732 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8733 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8734 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8735 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8736 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8737 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8738 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8747 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8756 /* ; idle */
8757 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8758 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8759 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8760 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8761 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8762 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8763 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8764 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8765 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8766 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8775 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8776 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8777 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8778 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8779 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8780 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8781 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8782 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8783 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8784 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8785 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8786 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8787 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8788 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8789 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8798 /* ;CR Registers */
8799 /* Config. Reg. 0 (filters) (cr0):FF */
8800 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8801 /* Config. Reg. 1 (dialing) (cr1):05 */
8802 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8803 /* Config. Reg. 2 (caller ID) (cr2):04 */
8804 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8805 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8806 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8807 /* Config. Reg. 4 (analog gain) (cr4):02 */
8808 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8809 /* Config. Reg. 5 (Version) (cr5):02 */
8810 /* Config. Reg. 6 (Reserved) (cr6):00 */
8811 /* Config. Reg. 7 (Reserved) (cr7):00 */
8812 /* ;xr Registers */
8813 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8814
8815 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8816 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8817
8818 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8819 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8820
8821 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8822 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8823 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8824 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8825 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8826 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8827 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8828 /* Ext. Reg. 6 (Power State) (xr6):00 */
8829 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8830 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8831 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8832 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8833 /* 12,33,5A,C3 ; 770 Hz */
8834 /* 13,3C,5B,32 ; 852 Hz */
8835 /* 1D,1B,5C,CC ; 941 Hz */
8836
8837 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8838 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8839 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8840 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8841 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8842 /* EC,1D,52,22 ; 1336 Hz */
8843 /* AA,AC,51,D2 ; 1477 Hz */
8844 /* 9B,3B,51,25 ; 1633 Hz */
8845 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8846 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8849 }
8850
8851 static s16 tone_table[][19] =
8852 {
8853 { /* f20_50[] 11 */
8854 32538, /* A1 = 1.985962 */
8855 -32325, /* A2 = -0.986511 */
8856 -343, /* B2 = -0.010493 */
8857 0, /* B1 = 0 */
8858 343, /* B0 = 0.010493 */
8859 32619, /* A1 = 1.990906 */
8860 -32520, /* A2 = -0.992462 */
8861 19179, /* B2 = 0.585327 */
8862 -19178, /* B1 = -1.170593 */
8863 19179, /* B0 = 0.585327 */
8864 32723, /* A1 = 1.997314 */
8865 -32686, /* A2 = -0.997528 */
8866 9973, /* B2 = 0.304352 */
8867 -9955, /* B1 = -0.607605 */
8868 9973, /* B0 = 0.304352 */
8869 7, /* Internal filter scaling */
8870 159, /* Minimum in-band energy threshold */
8871 21, /* 21/32 in-band to broad-band ratio */
8872 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8873 },
8874 { /* f133_200[] 12 */
8875 32072, /* A1 = 1.95752 */
8876 -31896, /* A2 = -0.973419 */
8877 -435, /* B2 = -0.013294 */
8878 0, /* B1 = 0 */
8879 435, /* B0 = 0.013294 */
8880 32188, /* A1 = 1.9646 */
8881 -32400, /* A2 = -0.98877 */
8882 15139, /* B2 = 0.462036 */
8883 -14882, /* B1 = -0.908356 */
8884 15139, /* B0 = 0.462036 */
8885 32473, /* A1 = 1.981995 */
8886 -32524, /* A2 = -0.992584 */
8887 23200, /* B2 = 0.708008 */
8888 -23113, /* B1 = -1.410706 */
8889 23200, /* B0 = 0.708008 */
8890 7, /* Internal filter scaling */
8891 159, /* Minimum in-band energy threshold */
8892 21, /* 21/32 in-band to broad-band ratio */
8893 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8894 },
8895 { /* f300 13 */
8896 31769, /* A1 = -1.939026 */
8897 -32584, /* A2 = 0.994385 */
8898 -475, /* B2 = -0.014522 */
8899 0, /* B1 = 0.000000 */
8900 475, /* B0 = 0.014522 */
8901 31789, /* A1 = -1.940247 */
8902 -32679, /* A2 = 0.997284 */
8903 17280, /* B2 = 0.527344 */
8904 -16865, /* B1 = -1.029358 */
8905 17280, /* B0 = 0.527344 */
8906 31841, /* A1 = -1.943481 */
8907 -32681, /* A2 = 0.997345 */
8908 543, /* B2 = 0.016579 */
8909 -525, /* B1 = -0.032097 */
8910 543, /* B0 = 0.016579 */
8911 5, /* Internal filter scaling */
8912 159, /* Minimum in-band energy threshold */
8913 21, /* 21/32 in-band to broad-band ratio */
8914 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8915 },
8916 { /* f300_420[] 14 */
8917 30750, /* A1 = 1.876892 */
8918 -31212, /* A2 = -0.952515 */
8919 -804, /* B2 = -0.024541 */
8920 0, /* B1 = 0 */
8921 804, /* B0 = 0.024541 */
8922 30686, /* A1 = 1.872925 */
8923 -32145, /* A2 = -0.980988 */
8924 14747, /* B2 = 0.450043 */
8925 -13703, /* B1 = -0.836395 */
8926 14747, /* B0 = 0.450043 */
8927 31651, /* A1 = 1.931824 */
8928 -32321, /* A2 = -0.986389 */
8929 24425, /* B2 = 0.745422 */
8930 -23914, /* B1 = -1.459595 */
8931 24427, /* B0 = 0.745483 */
8932 7, /* Internal filter scaling */
8933 159, /* Minimum in-band energy threshold */
8934 21, /* 21/32 in-band to broad-band ratio */
8935 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8936 },
8937 { /* f330 15 */
8938 31613, /* A1 = -1.929565 */
8939 -32646, /* A2 = 0.996277 */
8940 -185, /* B2 = -0.005657 */
8941 0, /* B1 = 0.000000 */
8942 185, /* B0 = 0.005657 */
8943 31620, /* A1 = -1.929932 */
8944 -32713, /* A2 = 0.998352 */
8945 19253, /* B2 = 0.587585 */
8946 -18566, /* B1 = -1.133179 */
8947 19253, /* B0 = 0.587585 */
8948 31674, /* A1 = -1.933228 */
8949 -32715, /* A2 = 0.998413 */
8950 2575, /* B2 = 0.078590 */
8951 -2495, /* B1 = -0.152283 */
8952 2575, /* B0 = 0.078590 */
8953 5, /* Internal filter scaling */
8954 159, /* Minimum in-band energy threshold */
8955 21, /* 21/32 in-band to broad-band ratio */
8956 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8957 },
8958 { /* f300_425[] 16 */
8959 30741, /* A1 = 1.876282 */
8960 -31475, /* A2 = -0.960541 */
8961 -703, /* B2 = -0.021484 */
8962 0, /* B1 = 0 */
8963 703, /* B0 = 0.021484 */
8964 30688, /* A1 = 1.873047 */
8965 -32248, /* A2 = -0.984161 */
8966 14542, /* B2 = 0.443787 */
8967 -13523, /* B1 = -0.825439 */
8968 14542, /* B0 = 0.443817 */
8969 31494, /* A1 = 1.922302 */
8970 -32366, /* A2 = -0.987762 */
8971 21577, /* B2 = 0.658508 */
8972 -21013, /* B1 = -1.282532 */
8973 21577, /* B0 = 0.658508 */
8974 7, /* Internal filter scaling */
8975 159, /* Minimum in-band energy threshold */
8976 21, /* 21/32 in-band to broad-band ratio */
8977 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8978 },
8979 { /* f330_440[] 17 */
8980 30627, /* A1 = 1.869324 */
8981 -31338, /* A2 = -0.95636 */
8982 -843, /* B2 = -0.025749 */
8983 0, /* B1 = 0 */
8984 843, /* B0 = 0.025749 */
8985 30550, /* A1 = 1.864685 */
8986 -32221, /* A2 = -0.983337 */
8987 13594, /* B2 = 0.414886 */
8988 -12589, /* B1 = -0.768402 */
8989 13594, /* B0 = 0.414886 */
8990 31488, /* A1 = 1.921936 */
8991 -32358, /* A2 = -0.987518 */
8992 24684, /* B2 = 0.753296 */
8993 -24029, /* B1 = -1.466614 */
8994 24684, /* B0 = 0.753296 */
8995 7, /* Internal filter scaling */
8996 159, /* Minimum in-band energy threshold */
8997 21, /* 21/32 in-band to broad-band ratio */
8998 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8999 },
9000 { /* f340 18 */
9001 31546, /* A1 = -1.925476 */
9002 -32646, /* A2 = 0.996277 */
9003 -445, /* B2 = -0.013588 */
9004 0, /* B1 = 0.000000 */
9005 445, /* B0 = 0.013588 */
9006 31551, /* A1 = -1.925781 */
9007 -32713, /* A2 = 0.998352 */
9008 23884, /* B2 = 0.728882 */
9009 -22979, /* B1 = -1.402527 */
9010 23884, /* B0 = 0.728882 */
9011 31606, /* A1 = -1.929138 */
9012 -32715, /* A2 = 0.998413 */
9013 863, /* B2 = 0.026367 */
9014 -835, /* B1 = -0.050985 */
9015 863, /* B0 = 0.026367 */
9016 5, /* Internal filter scaling */
9017 159, /* Minimum in-band energy threshold */
9018 21, /* 21/32 in-band to broad-band ratio */
9019 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9020 },
9021 { /* f350_400[] 19 */
9022 31006, /* A1 = 1.892517 */
9023 -32029, /* A2 = -0.977448 */
9024 -461, /* B2 = -0.014096 */
9025 0, /* B1 = 0 */
9026 461, /* B0 = 0.014096 */
9027 30999, /* A1 = 1.892029 */
9028 -32487, /* A2 = -0.991455 */
9029 11325, /* B2 = 0.345612 */
9030 -10682, /* B1 = -0.651978 */
9031 11325, /* B0 = 0.345612 */
9032 31441, /* A1 = 1.919067 */
9033 -32526, /* A2 = -0.992615 */
9034 24324, /* B2 = 0.74231 */
9035 -23535, /* B1 = -1.436523 */
9036 24324, /* B0 = 0.74231 */
9037 7, /* Internal filter scaling */
9038 159, /* Minimum in-band energy threshold */
9039 21, /* 21/32 in-band to broad-band ratio */
9040 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9041 },
9042 { /* f350_440[] */
9043 30634, /* A1 = 1.869751 */
9044 -31533, /* A2 = -0.962341 */
9045 -680, /* B2 = -0.020782 */
9046 0, /* B1 = 0 */
9047 680, /* B0 = 0.020782 */
9048 30571, /* A1 = 1.865906 */
9049 -32277, /* A2 = -0.985016 */
9050 12894, /* B2 = 0.393524 */
9051 -11945, /* B1 = -0.729065 */
9052 12894, /* B0 = 0.393524 */
9053 31367, /* A1 = 1.91449 */
9054 -32379, /* A2 = -0.988129 */
9055 23820, /* B2 = 0.726929 */
9056 -23104, /* B1 = -1.410217 */
9057 23820, /* B0 = 0.726929 */
9058 7, /* Internal filter scaling */
9059 159, /* Minimum in-band energy threshold */
9060 21, /* 21/32 in-band to broad-band ratio */
9061 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9062 },
9063 { /* f350_450[] */
9064 30552, /* A1 = 1.864807 */
9065 -31434, /* A2 = -0.95929 */
9066 -690, /* B2 = -0.021066 */
9067 0, /* B1 = 0 */
9068 690, /* B0 = 0.021066 */
9069 30472, /* A1 = 1.859924 */
9070 -32248, /* A2 = -0.984161 */
9071 13385, /* B2 = 0.408478 */
9072 -12357, /* B1 = -0.754242 */
9073 13385, /* B0 = 0.408478 */
9074 31358, /* A1 = 1.914001 */
9075 -32366, /* A2 = -0.987732 */
9076 26488, /* B2 = 0.80835 */
9077 -25692, /* B1 = -1.568176 */
9078 26490, /* B0 = 0.808411 */
9079 7, /* Internal filter scaling */
9080 159, /* Minimum in-band energy threshold */
9081 21, /* 21/32 in-band to broad-band ratio */
9082 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9083 },
9084 { /* f360 */
9085 31397, /* A1 = -1.916321 */
9086 -32623, /* A2 = 0.995605 */
9087 -117, /* B2 = -0.003598 */
9088 0, /* B1 = 0.000000 */
9089 117, /* B0 = 0.003598 */
9090 31403, /* A1 = -1.916687 */
9091 -32700, /* A2 = 0.997925 */
9092 3388, /* B2 = 0.103401 */
9093 -3240, /* B1 = -0.197784 */
9094 3388, /* B0 = 0.103401 */
9095 31463, /* A1 = -1.920410 */
9096 -32702, /* A2 = 0.997986 */
9097 13346, /* B2 = 0.407288 */
9098 -12863, /* B1 = -0.785126 */
9099 13346, /* B0 = 0.407288 */
9100 5, /* Internal filter scaling */
9101 159, /* Minimum in-band energy threshold */
9102 21, /* 21/32 in-band to broad-band ratio */
9103 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9104 },
9105 { /* f380_420[] */
9106 30831, /* A1 = 1.881775 */
9107 -32064, /* A2 = -0.978546 */
9108 -367, /* B2 = -0.01122 */
9109 0, /* B1 = 0 */
9110 367, /* B0 = 0.01122 */
9111 30813, /* A1 = 1.880737 */
9112 -32456, /* A2 = -0.990509 */
9113 11068, /* B2 = 0.337769 */
9114 -10338, /* B1 = -0.631042 */
9115 11068, /* B0 = 0.337769 */
9116 31214, /* A1 = 1.905212 */
9117 -32491, /* A2 = -0.991577 */
9118 16374, /* B2 = 0.499695 */
9119 -15781, /* B1 = -0.963196 */
9120 16374, /* B0 = 0.499695 */
9121 7, /* Internal filter scaling */
9122 159, /* Minimum in-band energy threshold */
9123 21, /* 21/32 in-band to broad-band ratio */
9124 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9125 },
9126 { /* f392 */
9127 31152, /* A1 = -1.901428 */
9128 -32613, /* A2 = 0.995300 */
9129 -314, /* B2 = -0.009605 */
9130 0, /* B1 = 0.000000 */
9131 314, /* B0 = 0.009605 */
9132 31156, /* A1 = -1.901672 */
9133 -32694, /* A2 = 0.997742 */
9134 28847, /* B2 = 0.880371 */
9135 -2734, /* B1 = -0.166901 */
9136 28847, /* B0 = 0.880371 */
9137 31225, /* A1 = -1.905823 */
9138 -32696, /* A2 = 0.997803 */
9139 462, /* B2 = 0.014108 */
9140 -442, /* B1 = -0.027019 */
9141 462, /* B0 = 0.014108 */
9142 5, /* Internal filter scaling */
9143 159, /* Minimum in-band energy threshold */
9144 21, /* 21/32 in-band to broad-band ratio */
9145 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9146 },
9147 { /* f400_425[] */
9148 30836, /* A1 = 1.882141 */
9149 -32296, /* A2 = -0.985596 */
9150 -324, /* B2 = -0.009903 */
9151 0, /* B1 = 0 */
9152 324, /* B0 = 0.009903 */
9153 30825, /* A1 = 1.881409 */
9154 -32570, /* A2 = -0.993958 */
9155 16847, /* B2 = 0.51416 */
9156 -15792, /* B1 = -0.963898 */
9157 16847, /* B0 = 0.51416 */
9158 31106, /* A1 = 1.89856 */
9159 -32584, /* A2 = -0.994415 */
9160 9579, /* B2 = 0.292328 */
9161 -9164, /* B1 = -0.559357 */
9162 9579, /* B0 = 0.292328 */
9163 7, /* Internal filter scaling */
9164 159, /* Minimum in-band energy threshold */
9165 21, /* 21/32 in-band to broad-band ratio */
9166 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9167 },
9168 { /* f400_440[] */
9169 30702, /* A1 = 1.873962 */
9170 -32134, /* A2 = -0.980682 */
9171 -517, /* B2 = -0.015793 */
9172 0, /* B1 = 0 */
9173 517, /* B0 = 0.015793 */
9174 30676, /* A1 = 1.872375 */
9175 -32520, /* A2 = -0.992462 */
9176 8144, /* B2 = 0.24855 */
9177 -7596, /* B1 = -0.463684 */
9178 8144, /* B0 = 0.24855 */
9179 31084, /* A1 = 1.897217 */
9180 -32547, /* A2 = -0.993256 */
9181 22713, /* B2 = 0.693176 */
9182 -21734, /* B1 = -1.326599 */
9183 22713, /* B0 = 0.693176 */
9184 7, /* Internal filter scaling */
9185 159, /* Minimum in-band energy threshold */
9186 21, /* 21/32 in-band to broad-band ratio */
9187 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9188 },
9189 { /* f400_450[] */
9190 30613, /* A1 = 1.86853 */
9191 -32031, /* A2 = -0.977509 */
9192 -618, /* B2 = -0.018866 */
9193 0, /* B1 = 0 */
9194 618, /* B0 = 0.018866 */
9195 30577, /* A1 = 1.866272 */
9196 -32491, /* A2 = -0.991577 */
9197 9612, /* B2 = 0.293335 */
9198 -8935, /* B1 = -0.54541 */
9199 9612, /* B0 = 0.293335 */
9200 31071, /* A1 = 1.896484 */
9201 -32524, /* A2 = -0.992584 */
9202 21596, /* B2 = 0.659058 */
9203 -20667, /* B1 = -1.261414 */
9204 21596, /* B0 = 0.659058 */
9205 7, /* Internal filter scaling */
9206 159, /* Minimum in-band energy threshold */
9207 21, /* 21/32 in-band to broad-band ratio */
9208 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9209 },
9210 { /* f420 */
9211 30914, /* A1 = -1.886841 */
9212 -32584, /* A2 = 0.994385 */
9213 -426, /* B2 = -0.013020 */
9214 0, /* B1 = 0.000000 */
9215 426, /* B0 = 0.013020 */
9216 30914, /* A1 = -1.886841 */
9217 -32679, /* A2 = 0.997314 */
9218 17520, /* B2 = 0.534668 */
9219 -16471, /* B1 = -1.005310 */
9220 17520, /* B0 = 0.534668 */
9221 31004, /* A1 = -1.892334 */
9222 -32683, /* A2 = 0.997406 */
9223 819, /* B2 = 0.025023 */
9224 -780, /* B1 = -0.047619 */
9225 819, /* B0 = 0.025023 */
9226 5, /* Internal filter scaling */
9227 159, /* Minimum in-band energy threshold */
9228 21, /* 21/32 in-band to broad-band ratio */
9229 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9230 },
9231 #if 0
9232 { /* f425 */
9233 30881, /* A1 = -1.884827 */
9234 -32603, /* A2 = 0.994965 */
9235 -496, /* B2 = -0.015144 */
9236 0, /* B1 = 0.000000 */
9237 496, /* B0 = 0.015144 */
9238 30880, /* A1 = -1.884766 */
9239 -32692, /* A2 = 0.997711 */
9240 24767, /* B2 = 0.755859 */
9241 -23290, /* B1 = -1.421509 */
9242 24767, /* B0 = 0.755859 */
9243 30967, /* A1 = -1.890076 */
9244 -32694, /* A2 = 0.997772 */
9245 728, /* B2 = 0.022232 */
9246 -691, /* B1 = -0.042194 */
9247 728, /* B0 = 0.022232 */
9248 5, /* Internal filter scaling */
9249 159, /* Minimum in-band energy threshold */
9250 21, /* 21/32 in-band to broad-band ratio */
9251 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9252 },
9253 #else
9254 {
9255 30850,
9256 -32534,
9257 -504,
9258 0,
9259 504,
9260 30831,
9261 -32669,
9262 24303,
9263 -22080,
9264 24303,
9265 30994,
9266 -32673,
9267 1905,
9268 -1811,
9269 1905,
9270 5,
9271 129,
9272 17,
9273 0xff5
9274 },
9275 #endif
9276 { /* f425_450[] */
9277 30646, /* A1 = 1.870544 */
9278 -32327, /* A2 = -0.986572 */
9279 -287, /* B2 = -0.008769 */
9280 0, /* B1 = 0 */
9281 287, /* B0 = 0.008769 */
9282 30627, /* A1 = 1.869324 */
9283 -32607, /* A2 = -0.995087 */
9284 13269, /* B2 = 0.404968 */
9285 -12376, /* B1 = -0.755432 */
9286 13269, /* B0 = 0.404968 */
9287 30924, /* A1 = 1.887512 */
9288 -32619, /* A2 = -0.995453 */
9289 19950, /* B2 = 0.608826 */
9290 -18940, /* B1 = -1.156006 */
9291 19950, /* B0 = 0.608826 */
9292 7, /* Internal filter scaling */
9293 159, /* Minimum in-band energy threshold */
9294 21, /* 21/32 in-band to broad-band ratio */
9295 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9296 },
9297 { /* f425_475[] */
9298 30396, /* A1 = 1.855225 */
9299 -32014, /* A2 = -0.97699 */
9300 -395, /* B2 = -0.012055 */
9301 0, /* B1 = 0 */
9302 395, /* B0 = 0.012055 */
9303 30343, /* A1 = 1.85199 */
9304 -32482, /* A2 = -0.991302 */
9305 17823, /* B2 = 0.543945 */
9306 -16431, /* B1 = -1.002869 */
9307 17823, /* B0 = 0.543945 */
9308 30872, /* A1 = 1.884338 */
9309 -32516, /* A2 = -0.99231 */
9310 18124, /* B2 = 0.553101 */
9311 -17246, /* B1 = -1.052673 */
9312 18124, /* B0 = 0.553101 */
9313 7, /* Internal filter scaling */
9314 159, /* Minimum in-band energy threshold */
9315 21, /* 21/32 in-band to broad-band ratio */
9316 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9317 },
9318 { /* f435 */
9319 30796, /* A1 = -1.879639 */
9320 -32603, /* A2 = 0.994965 */
9321 -254, /* B2 = -0.007762 */
9322 0, /* B1 = 0.000000 */
9323 254, /* B0 = 0.007762 */
9324 30793, /* A1 = -1.879456 */
9325 -32692, /* A2 = 0.997711 */
9326 18934, /* B2 = 0.577820 */
9327 -17751, /* B1 = -1.083496 */
9328 18934, /* B0 = 0.577820 */
9329 30882, /* A1 = -1.884888 */
9330 -32694, /* A2 = 0.997772 */
9331 1858, /* B2 = 0.056713 */
9332 -1758, /* B1 = -0.107357 */
9333 1858, /* B0 = 0.056713 */
9334 5, /* Internal filter scaling */
9335 159, /* Minimum in-band energy threshold */
9336 21, /* 21/32 in-band to broad-band ratio */
9337 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9338 },
9339 { /* f440_450[] */
9340 30641, /* A1 = 1.870239 */
9341 -32458, /* A2 = -0.99057 */
9342 -155, /* B2 = -0.004735 */
9343 0, /* B1 = 0 */
9344 155, /* B0 = 0.004735 */
9345 30631, /* A1 = 1.869568 */
9346 -32630, /* A2 = -0.995789 */
9347 11453, /* B2 = 0.349548 */
9348 -10666, /* B1 = -0.651001 */
9349 11453, /* B0 = 0.349548 */
9350 30810, /* A1 = 1.880554 */
9351 -32634, /* A2 = -0.995941 */
9352 12237, /* B2 = 0.373474 */
9353 -11588, /* B1 = -0.707336 */
9354 12237, /* B0 = 0.373474 */
9355 7, /* Internal filter scaling */
9356 159, /* Minimum in-band energy threshold */
9357 21, /* 21/32 in-band to broad-band ratio */
9358 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9359 },
9360 { /* f440_480[] */
9361 30367, /* A1 = 1.853455 */
9362 -32147, /* A2 = -0.981079 */
9363 -495, /* B2 = -0.015113 */
9364 0, /* B1 = 0 */
9365 495, /* B0 = 0.015113 */
9366 30322, /* A1 = 1.850769 */
9367 -32543, /* A2 = -0.993134 */
9368 10031, /* B2 = 0.306152 */
9369 -9252, /* B1 = -0.564728 */
9370 10031, /* B0 = 0.306152 */
9371 30770, /* A1 = 1.878052 */
9372 -32563, /* A2 = -0.993774 */
9373 22674, /* B2 = 0.691956 */
9374 -21465, /* B1 = -1.31012 */
9375 22674, /* B0 = 0.691956 */
9376 7, /* Internal filter scaling */
9377 159, /* Minimum in-band energy threshold */
9378 21, /* 21/32 in-band to broad-band ratio */
9379 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9380 },
9381 { /* f445 */
9382 30709, /* A1 = -1.874329 */
9383 -32603, /* A2 = 0.994965 */
9384 -83, /* B2 = -0.002545 */
9385 0, /* B1 = 0.000000 */
9386 83, /* B0 = 0.002545 */
9387 30704, /* A1 = -1.874084 */
9388 -32692, /* A2 = 0.997711 */
9389 10641, /* B2 = 0.324738 */
9390 -9947, /* B1 = -0.607147 */
9391 10641, /* B0 = 0.324738 */
9392 30796, /* A1 = -1.879639 */
9393 -32694, /* A2 = 0.997772 */
9394 10079, /* B2 = 0.307587 */
9395 9513, /* B1 = 0.580688 */
9396 10079, /* B0 = 0.307587 */
9397 5, /* Internal filter scaling */
9398 159, /* Minimum in-band energy threshold */
9399 21, /* 21/32 in-band to broad-band ratio */
9400 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9401 },
9402 { /* f450 */
9403 30664, /* A1 = -1.871643 */
9404 -32603, /* A2 = 0.994965 */
9405 -164, /* B2 = -0.005029 */
9406 0, /* B1 = 0.000000 */
9407 164, /* B0 = 0.005029 */
9408 30661, /* A1 = -1.871399 */
9409 -32692, /* A2 = 0.997711 */
9410 15294, /* B2 = 0.466736 */
9411 -14275, /* B1 = -0.871307 */
9412 15294, /* B0 = 0.466736 */
9413 30751, /* A1 = -1.876953 */
9414 -32694, /* A2 = 0.997772 */
9415 3548, /* B2 = 0.108284 */
9416 -3344, /* B1 = -0.204155 */
9417 3548, /* B0 = 0.108284 */
9418 5, /* Internal filter scaling */
9419 159, /* Minimum in-band energy threshold */
9420 21, /* 21/32 in-band to broad-band ratio */
9421 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9422 },
9423 { /* f452 */
9424 30653, /* A1 = -1.870911 */
9425 -32615, /* A2 = 0.995361 */
9426 -209, /* B2 = -0.006382 */
9427 0, /* B1 = 0.000000 */
9428 209, /* B0 = 0.006382 */
9429 30647, /* A1 = -1.870605 */
9430 -32702, /* A2 = 0.997986 */
9431 18971, /* B2 = 0.578979 */
9432 -17716, /* B1 = -1.081299 */
9433 18971, /* B0 = 0.578979 */
9434 30738, /* A1 = -1.876099 */
9435 -32702, /* A2 = 0.998016 */
9436 2967, /* B2 = 0.090561 */
9437 -2793, /* B1 = -0.170502 */
9438 2967, /* B0 = 0.090561 */
9439 5, /* Internal filter scaling */
9440 159, /* Minimum in-band energy threshold */
9441 21, /* 21/32 in-band to broad-band ratio */
9442 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9443 },
9444 { /* f475 */
9445 30437, /* A1 = -1.857727 */
9446 -32603, /* A2 = 0.994965 */
9447 -264, /* B2 = -0.008062 */
9448 0, /* B1 = 0.000000 */
9449 264, /* B0 = 0.008062 */
9450 30430, /* A1 = -1.857300 */
9451 -32692, /* A2 = 0.997711 */
9452 21681, /* B2 = 0.661682 */
9453 -20082, /* B1 = -1.225708 */
9454 21681, /* B0 = 0.661682 */
9455 30526, /* A1 = -1.863220 */
9456 -32694, /* A2 = 0.997742 */
9457 1559, /* B2 = 0.047600 */
9458 -1459, /* B1 = -0.089096 */
9459 1559, /* B0 = 0.047600 */
9460 5, /* Internal filter scaling */
9461 159, /* Minimum in-band energy threshold */
9462 21, /* 21/32 in-band to broad-band ratio */
9463 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9464 },
9465 { /* f480_620[] */
9466 28975, /* A1 = 1.768494 */
9467 -30955, /* A2 = -0.944672 */
9468 -1026, /* B2 = -0.03133 */
9469 0, /* B1 = 0 */
9470 1026, /* B0 = 0.03133 */
9471 28613, /* A1 = 1.746399 */
9472 -32089, /* A2 = -0.979309 */
9473 14214, /* B2 = 0.433807 */
9474 -12202, /* B1 = -0.744812 */
9475 14214, /* B0 = 0.433807 */
9476 30243, /* A1 = 1.845947 */
9477 -32238, /* A2 = -0.983856 */
9478 24825, /* B2 = 0.757629 */
9479 -23402, /* B1 = -1.428345 */
9480 24825, /* B0 = 0.757629 */
9481 7, /* Internal filter scaling */
9482 159, /* Minimum in-band energy threshold */
9483 21, /* 21/32 in-band to broad-band ratio */
9484 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9485 },
9486 { /* f494 */
9487 30257, /* A1 = -1.846741 */
9488 -32605, /* A2 = 0.995056 */
9489 -249, /* B2 = -0.007625 */
9490 0, /* B1 = 0.000000 */
9491 249, /* B0 = 0.007625 */
9492 30247, /* A1 = -1.846191 */
9493 -32694, /* A2 = 0.997772 */
9494 18088, /* B2 = 0.552002 */
9495 -16652, /* B1 = -1.016418 */
9496 18088, /* B0 = 0.552002 */
9497 30348, /* A1 = -1.852295 */
9498 -32696, /* A2 = 0.997803 */
9499 2099, /* B2 = 0.064064 */
9500 -1953, /* B1 = -0.119202 */
9501 2099, /* B0 = 0.064064 */
9502 5, /* Internal filter scaling */
9503 159, /* Minimum in-band energy threshold */
9504 21, /* 21/32 in-band to broad-band ratio */
9505 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9506 },
9507 { /* f500 */
9508 30202, /* A1 = -1.843431 */
9509 -32624, /* A2 = 0.995622 */
9510 -413, /* B2 = -0.012622 */
9511 0, /* B1 = 0.000000 */
9512 413, /* B0 = 0.012622 */
9513 30191, /* A1 = -1.842721 */
9514 -32714, /* A2 = 0.998364 */
9515 25954, /* B2 = 0.792057 */
9516 -23890, /* B1 = -1.458131 */
9517 25954, /* B0 = 0.792057 */
9518 30296, /* A1 = -1.849172 */
9519 -32715, /* A2 = 0.998397 */
9520 2007, /* B2 = 0.061264 */
9521 -1860, /* B1 = -0.113568 */
9522 2007, /* B0 = 0.061264 */
9523 5, /* Internal filter scaling */
9524 159, /* Minimum in-band energy threshold */
9525 21, /* 21/32 in-band to broad-band ratio */
9526 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9527 },
9528 { /* f520 */
9529 30001, /* A1 = -1.831116 */
9530 -32613, /* A2 = 0.995270 */
9531 -155, /* B2 = -0.004750 */
9532 0, /* B1 = 0.000000 */
9533 155, /* B0 = 0.004750 */
9534 29985, /* A1 = -1.830200 */
9535 -32710, /* A2 = 0.998260 */
9536 6584, /* B2 = 0.200928 */
9537 -6018, /* B1 = -0.367355 */
9538 6584, /* B0 = 0.200928 */
9539 30105, /* A1 = -1.837524 */
9540 -32712, /* A2 = 0.998291 */
9541 23812, /* B2 = 0.726685 */
9542 -21936, /* B1 = -1.338928 */
9543 23812, /* B0 = 0.726685 */
9544 5, /* Internal filter scaling */
9545 159, /* Minimum in-band energy threshold */
9546 21, /* 21/32 in-band to broad-band ratio */
9547 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9548 },
9549 { /* f523 */
9550 29964, /* A1 = -1.828918 */
9551 -32601, /* A2 = 0.994904 */
9552 -101, /* B2 = -0.003110 */
9553 0, /* B1 = 0.000000 */
9554 101, /* B0 = 0.003110 */
9555 29949, /* A1 = -1.827942 */
9556 -32700, /* A2 = 0.997925 */
9557 11041, /* B2 = 0.336975 */
9558 -10075, /* B1 = -0.614960 */
9559 11041, /* B0 = 0.336975 */
9560 30070, /* A1 = -1.835388 */
9561 -32702, /* A2 = 0.997986 */
9562 16762, /* B2 = 0.511536 */
9563 -15437, /* B1 = -0.942230 */
9564 16762, /* B0 = 0.511536 */
9565 5, /* Internal filter scaling */
9566 159, /* Minimum in-band energy threshold */
9567 21, /* 21/32 in-band to broad-band ratio */
9568 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9569 },
9570 { /* f525 */
9571 29936, /* A1 = -1.827209 */
9572 -32584, /* A2 = 0.994415 */
9573 -91, /* B2 = -0.002806 */
9574 0, /* B1 = 0.000000 */
9575 91, /* B0 = 0.002806 */
9576 29921, /* A1 = -1.826233 */
9577 -32688, /* A2 = 0.997559 */
9578 11449, /* B2 = 0.349396 */
9579 -10426, /* B1 = -0.636383 */
9580 11449, /* B0 = 0.349396 */
9581 30045, /* A1 = -1.833862 */
9582 -32688, /* A2 = 0.997589 */
9583 13055, /* B2 = 0.398407 */
9584 -12028, /* B1 = -0.734161 */
9585 13055, /* B0 = 0.398407 */
9586 5, /* Internal filter scaling */
9587 159, /* Minimum in-band energy threshold */
9588 21, /* 21/32 in-band to broad-band ratio */
9589 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9590 },
9591 { /* f540_660[] */
9592 28499, /* A1 = 1.739441 */
9593 -31129, /* A2 = -0.949982 */
9594 -849, /* B2 = -0.025922 */
9595 0, /* B1 = 0 */
9596 849, /* B0 = 0.025922 */
9597 28128, /* A1 = 1.716797 */
9598 -32130, /* A2 = -0.98056 */
9599 14556, /* B2 = 0.444214 */
9600 -12251, /* B1 = -0.747772 */
9601 14556, /* B0 = 0.444244 */
9602 29667, /* A1 = 1.81073 */
9603 -32244, /* A2 = -0.984039 */
9604 23038, /* B2 = 0.703064 */
9605 -21358, /* B1 = -1.303589 */
9606 23040, /* B0 = 0.703125 */
9607 7, /* Internal filter scaling */
9608 159, /* Minimum in-band energy threshold */
9609 21, /* 21/32 in-band to broad-band ratio */
9610 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9611 },
9612 { /* f587 */
9613 29271, /* A1 = -1.786560 */
9614 -32599, /* A2 = 0.994873 */
9615 -490, /* B2 = -0.014957 */
9616 0, /* B1 = 0.000000 */
9617 490, /* B0 = 0.014957 */
9618 29246, /* A1 = -1.785095 */
9619 -32700, /* A2 = 0.997925 */
9620 28961, /* B2 = 0.883850 */
9621 -25796, /* B1 = -1.574463 */
9622 28961, /* B0 = 0.883850 */
9623 29383, /* A1 = -1.793396 */
9624 -32700, /* A2 = 0.997955 */
9625 1299, /* B2 = 0.039650 */
9626 -1169, /* B1 = -0.071396 */
9627 1299, /* B0 = 0.039650 */
9628 5, /* Internal filter scaling */
9629 159, /* Minimum in-band energy threshold */
9630 21, /* 21/32 in-band to broad-band ratio */
9631 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9632 },
9633 { /* f590 */
9634 29230, /* A1 = -1.784058 */
9635 -32584, /* A2 = 0.994415 */
9636 -418, /* B2 = -0.012757 */
9637 0, /* B1 = 0.000000 */
9638 418, /* B0 = 0.012757 */
9639 29206, /* A1 = -1.782593 */
9640 -32688, /* A2 = 0.997559 */
9641 36556, /* B2 = 1.115601 */
9642 -32478, /* B1 = -1.982300 */
9643 36556, /* B0 = 1.115601 */
9644 29345, /* A1 = -1.791077 */
9645 -32688, /* A2 = 0.997589 */
9646 897, /* B2 = 0.027397 */
9647 -808, /* B1 = -0.049334 */
9648 897, /* B0 = 0.027397 */
9649 5, /* Internal filter scaling */
9650 159, /* Minimum in-band energy threshold */
9651 21, /* 21/32 in-band to broad-band ratio */
9652 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9653 },
9654 { /* f600 */
9655 29116, /* A1 = -1.777100 */
9656 -32603, /* A2 = 0.994965 */
9657 -165, /* B2 = -0.005039 */
9658 0, /* B1 = 0.000000 */
9659 165, /* B0 = 0.005039 */
9660 29089, /* A1 = -1.775452 */
9661 -32708, /* A2 = 0.998199 */
9662 6963, /* B2 = 0.212494 */
9663 -6172, /* B1 = -0.376770 */
9664 6963, /* B0 = 0.212494 */
9665 29237, /* A1 = -1.784485 */
9666 -32710, /* A2 = 0.998230 */
9667 24197, /* B2 = 0.738464 */
9668 -21657, /* B1 = -1.321899 */
9669 24197, /* B0 = 0.738464 */
9670 5, /* Internal filter scaling */
9671 159, /* Minimum in-band energy threshold */
9672 21, /* 21/32 in-band to broad-band ratio */
9673 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9674 },
9675 { /* f660 */
9676 28376, /* A1 = -1.731934 */
9677 -32567, /* A2 = 0.993896 */
9678 -363, /* B2 = -0.011102 */
9679 0, /* B1 = 0.000000 */
9680 363, /* B0 = 0.011102 */
9681 28337, /* A1 = -1.729614 */
9682 -32683, /* A2 = 0.997434 */
9683 21766, /* B2 = 0.664246 */
9684 -18761, /* B1 = -1.145081 */
9685 21766, /* B0 = 0.664246 */
9686 28513, /* A1 = -1.740356 */
9687 -32686, /* A2 = 0.997498 */
9688 2509, /* B2 = 0.076584 */
9689 -2196, /* B1 = -0.134041 */
9690 2509, /* B0 = 0.076584 */
9691 5, /* Internal filter scaling */
9692 159, /* Minimum in-band energy threshold */
9693 21, /* 21/32 in-band to broad-band ratio */
9694 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9695 },
9696 { /* f700 */
9697 27844, /* A1 = -1.699463 */
9698 -32563, /* A2 = 0.993744 */
9699 -366, /* B2 = -0.011187 */
9700 0, /* B1 = 0.000000 */
9701 366, /* B0 = 0.011187 */
9702 27797, /* A1 = -1.696655 */
9703 -32686, /* A2 = 0.997498 */
9704 22748, /* B2 = 0.694214 */
9705 -19235, /* B1 = -1.174072 */
9706 22748, /* B0 = 0.694214 */
9707 27995, /* A1 = -1.708740 */
9708 -32688, /* A2 = 0.997559 */
9709 2964, /* B2 = 0.090477 */
9710 -2546, /* B1 = -0.155449 */
9711 2964, /* B0 = 0.090477 */
9712 5, /* Internal filter scaling */
9713 159, /* Minimum in-band energy threshold */
9714 21, /* 21/32 in-band to broad-band ratio */
9715 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9716 },
9717 { /* f740 */
9718 27297, /* A1 = -1.666077 */
9719 -32551, /* A2 = 0.993408 */
9720 -345, /* B2 = -0.010540 */
9721 0, /* B1 = 0.000000 */
9722 345, /* B0 = 0.010540 */
9723 27240, /* A1 = -1.662598 */
9724 -32683, /* A2 = 0.997406 */
9725 22560, /* B2 = 0.688477 */
9726 -18688, /* B1 = -1.140625 */
9727 22560, /* B0 = 0.688477 */
9728 27461, /* A1 = -1.676147 */
9729 -32684, /* A2 = 0.997467 */
9730 3541, /* B2 = 0.108086 */
9731 -2985, /* B1 = -0.182220 */
9732 3541, /* B0 = 0.108086 */
9733 5, /* Internal filter scaling */
9734 159, /* Minimum in-band energy threshold */
9735 21, /* 21/32 in-band to broad-band ratio */
9736 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9737 },
9738 { /* f750 */
9739 27155, /* A1 = -1.657410 */
9740 -32551, /* A2 = 0.993408 */
9741 -462, /* B2 = -0.014117 */
9742 0, /* B1 = 0.000000 */
9743 462, /* B0 = 0.014117 */
9744 27097, /* A1 = -1.653870 */
9745 -32683, /* A2 = 0.997406 */
9746 32495, /* B2 = 0.991699 */
9747 -26776, /* B1 = -1.634338 */
9748 32495, /* B0 = 0.991699 */
9749 27321, /* A1 = -1.667542 */
9750 -32684, /* A2 = 0.997467 */
9751 1835, /* B2 = 0.056007 */
9752 -1539, /* B1 = -0.093948 */
9753 1835, /* B0 = 0.056007 */
9754 5, /* Internal filter scaling */
9755 159, /* Minimum in-band energy threshold */
9756 21, /* 21/32 in-band to broad-band ratio */
9757 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9758 },
9759 { /* f750_1450[] */
9760 19298, /* A1 = 1.177917 */
9761 -24471, /* A2 = -0.746796 */
9762 -4152, /* B2 = -0.126709 */
9763 0, /* B1 = 0 */
9764 4152, /* B0 = 0.126709 */
9765 12902, /* A1 = 0.787476 */
9766 -29091, /* A2 = -0.887817 */
9767 12491, /* B2 = 0.38121 */
9768 -1794, /* B1 = -0.109528 */
9769 12494, /* B0 = 0.381317 */
9770 26291, /* A1 = 1.604736 */
9771 -30470, /* A2 = -0.929901 */
9772 28859, /* B2 = 0.880737 */
9773 -26084, /* B1 = -1.592102 */
9774 28861, /* B0 = 0.880798 */
9775 7, /* Internal filter scaling */
9776 159, /* Minimum in-band energy threshold */
9777 21, /* 21/32 in-band to broad-band ratio */
9778 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9779 },
9780 { /* f770 */
9781 26867, /* A1 = -1.639832 */
9782 -32551, /* A2 = 0.993408 */
9783 -123, /* B2 = -0.003755 */
9784 0, /* B1 = 0.000000 */
9785 123, /* B0 = 0.003755 */
9786 26805, /* A1 = -1.636108 */
9787 -32683, /* A2 = 0.997406 */
9788 17297, /* B2 = 0.527863 */
9789 -14096, /* B1 = -0.860382 */
9790 17297, /* B0 = 0.527863 */
9791 27034, /* A1 = -1.650085 */
9792 -32684, /* A2 = 0.997467 */
9793 12958, /* B2 = 0.395477 */
9794 -10756, /* B1 = -0.656525 */
9795 12958, /* B0 = 0.395477 */
9796 5, /* Internal filter scaling */
9797 159, /* Minimum in-band energy threshold */
9798 21, /* 21/32 in-band to broad-band ratio */
9799 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9800 },
9801 { /* f800 */
9802 26413, /* A1 = -1.612122 */
9803 -32547, /* A2 = 0.993286 */
9804 -223, /* B2 = -0.006825 */
9805 0, /* B1 = 0.000000 */
9806 223, /* B0 = 0.006825 */
9807 26342, /* A1 = -1.607849 */
9808 -32686, /* A2 = 0.997498 */
9809 6391, /* B2 = 0.195053 */
9810 -5120, /* B1 = -0.312531 */
9811 6391, /* B0 = 0.195053 */
9812 26593, /* A1 = -1.623108 */
9813 -32688, /* A2 = 0.997559 */
9814 23681, /* B2 = 0.722717 */
9815 -19328, /* B1 = -1.179688 */
9816 23681, /* B0 = 0.722717 */
9817 5, /* Internal filter scaling */
9818 159, /* Minimum in-band energy threshold */
9819 21, /* 21/32 in-band to broad-band ratio */
9820 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9821 },
9822 { /* f816 */
9823 26168, /* A1 = -1.597209 */
9824 -32528, /* A2 = 0.992706 */
9825 -235, /* B2 = -0.007182 */
9826 0, /* B1 = 0.000000 */
9827 235, /* B0 = 0.007182 */
9828 26092, /* A1 = -1.592590 */
9829 -32675, /* A2 = 0.997192 */
9830 20823, /* B2 = 0.635498 */
9831 -16510, /* B1 = -1.007751 */
9832 20823, /* B0 = 0.635498 */
9833 26363, /* A1 = -1.609070 */
9834 -32677, /* A2 = 0.997253 */
9835 6739, /* B2 = 0.205688 */
9836 -5459, /* B1 = -0.333206 */
9837 6739, /* B0 = 0.205688 */
9838 5, /* Internal filter scaling */
9839 159, /* Minimum in-band energy threshold */
9840 21, /* 21/32 in-band to broad-band ratio */
9841 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9842 },
9843 { /* f850 */
9844 25641, /* A1 = -1.565063 */
9845 -32536, /* A2 = 0.992950 */
9846 -121, /* B2 = -0.003707 */
9847 0, /* B1 = 0.000000 */
9848 121, /* B0 = 0.003707 */
9849 25560, /* A1 = -1.560059 */
9850 -32684, /* A2 = 0.997437 */
9851 18341, /* B2 = 0.559753 */
9852 -14252, /* B1 = -0.869904 */
9853 18341, /* B0 = 0.559753 */
9854 25837, /* A1 = -1.577026 */
9855 -32684, /* A2 = 0.997467 */
9856 16679, /* B2 = 0.509003 */
9857 -13232, /* B1 = -0.807648 */
9858 16679, /* B0 = 0.509003 */
9859 5, /* Internal filter scaling */
9860 159, /* Minimum in-band energy threshold */
9861 21, /* 21/32 in-band to broad-band ratio */
9862 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9863 },
9864 { /* f857_1645[] */
9865 16415, /* A1 = 1.001953 */
9866 -23669, /* A2 = -0.722321 */
9867 -4549, /* B2 = -0.138847 */
9868 0, /* B1 = 0 */
9869 4549, /* B0 = 0.138847 */
9870 8456, /* A1 = 0.516174 */
9871 -28996, /* A2 = -0.884918 */
9872 13753, /* B2 = 0.419724 */
9873 -12, /* B1 = -0.000763 */
9874 13757, /* B0 = 0.419846 */
9875 24632, /* A1 = 1.503418 */
9876 -30271, /* A2 = -0.923828 */
9877 29070, /* B2 = 0.887146 */
9878 -25265, /* B1 = -1.542114 */
9879 29073, /* B0 = 0.887268 */
9880 7, /* Internal filter scaling */
9881 159, /* Minimum in-band energy threshold */
9882 21, /* 21/32 in-band to broad-band ratio */
9883 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9884 },
9885 { /* f900 */
9886 24806, /* A1 = -1.514099 */
9887 -32501, /* A2 = 0.991852 */
9888 -326, /* B2 = -0.009969 */
9889 0, /* B1 = 0.000000 */
9890 326, /* B0 = 0.009969 */
9891 24709, /* A1 = -1.508118 */
9892 -32659, /* A2 = 0.996674 */
9893 20277, /* B2 = 0.618835 */
9894 -15182, /* B1 = -0.926636 */
9895 20277, /* B0 = 0.618835 */
9896 25022, /* A1 = -1.527222 */
9897 -32661, /* A2 = 0.996735 */
9898 4320, /* B2 = 0.131836 */
9899 -3331, /* B1 = -0.203339 */
9900 4320, /* B0 = 0.131836 */
9901 5, /* Internal filter scaling */
9902 159, /* Minimum in-band energy threshold */
9903 21, /* 21/32 in-band to broad-band ratio */
9904 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9905 },
9906 { /* f900_1300[] */
9907 19776, /* A1 = 1.207092 */
9908 -27437, /* A2 = -0.837341 */
9909 -2666, /* B2 = -0.081371 */
9910 0, /* B1 = 0 */
9911 2666, /* B0 = 0.081371 */
9912 16302, /* A1 = 0.995026 */
9913 -30354, /* A2 = -0.926361 */
9914 10389, /* B2 = 0.317062 */
9915 -3327, /* B1 = -0.203064 */
9916 10389, /* B0 = 0.317062 */
9917 24299, /* A1 = 1.483154 */
9918 -30930, /* A2 = -0.943909 */
9919 25016, /* B2 = 0.763428 */
9920 -21171, /* B1 = -1.292236 */
9921 25016, /* B0 = 0.763428 */
9922 7, /* Internal filter scaling */
9923 159, /* Minimum in-band energy threshold */
9924 21, /* 21/32 in-band to broad-band ratio */
9925 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9926 },
9927 { /* f935_1215[] */
9928 20554, /* A1 = 1.254517 */
9929 -28764, /* A2 = -0.877838 */
9930 -2048, /* B2 = -0.062515 */
9931 0, /* B1 = 0 */
9932 2048, /* B0 = 0.062515 */
9933 18209, /* A1 = 1.11145 */
9934 -30951, /* A2 = -0.94458 */
9935 9390, /* B2 = 0.286575 */
9936 -3955, /* B1 = -0.241455 */
9937 9390, /* B0 = 0.286575 */
9938 23902, /* A1 = 1.458923 */
9939 -31286, /* A2 = -0.954803 */
9940 23252, /* B2 = 0.709595 */
9941 -19132, /* B1 = -1.167725 */
9942 23252, /* B0 = 0.709595 */
9943 7, /* Internal filter scaling */
9944 159, /* Minimum in-band energy threshold */
9945 21, /* 21/32 in-band to broad-band ratio */
9946 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9947 },
9948 { /* f941_1477[] */
9949 17543, /* A1 = 1.07074 */
9950 -26220, /* A2 = -0.800201 */
9951 -3298, /* B2 = -0.100647 */
9952 0, /* B1 = 0 */
9953 3298, /* B0 = 0.100647 */
9954 12423, /* A1 = 0.75827 */
9955 -30036, /* A2 = -0.916626 */
9956 12651, /* B2 = 0.386078 */
9957 -2444, /* B1 = -0.14917 */
9958 12653, /* B0 = 0.386154 */
9959 23518, /* A1 = 1.435425 */
9960 -30745, /* A2 = -0.938293 */
9961 27282, /* B2 = 0.832581 */
9962 -22529, /* B1 = -1.375122 */
9963 27286, /* B0 = 0.832703 */
9964 7, /* Internal filter scaling */
9965 159, /* Minimum in-band energy threshold */
9966 21, /* 21/32 in-band to broad-band ratio */
9967 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9968 },
9969 { /* f942 */
9970 24104, /* A1 = -1.471252 */
9971 -32507, /* A2 = 0.992065 */
9972 -351, /* B2 = -0.010722 */
9973 0, /* B1 = 0.000000 */
9974 351, /* B0 = 0.010722 */
9975 23996, /* A1 = -1.464600 */
9976 -32671, /* A2 = 0.997040 */
9977 22848, /* B2 = 0.697266 */
9978 -16639, /* B1 = -1.015564 */
9979 22848, /* B0 = 0.697266 */
9980 24332, /* A1 = -1.485168 */
9981 -32673, /* A2 = 0.997101 */
9982 4906, /* B2 = 0.149727 */
9983 -3672, /* B1 = -0.224174 */
9984 4906, /* B0 = 0.149727 */
9985 5, /* Internal filter scaling */
9986 159, /* Minimum in-band energy threshold */
9987 21, /* 21/32 in-band to broad-band ratio */
9988 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9989 },
9990 { /* f950 */
9991 23967, /* A1 = -1.462830 */
9992 -32507, /* A2 = 0.992065 */
9993 -518, /* B2 = -0.015821 */
9994 0, /* B1 = 0.000000 */
9995 518, /* B0 = 0.015821 */
9996 23856, /* A1 = -1.456055 */
9997 -32671, /* A2 = 0.997040 */
9998 26287, /* B2 = 0.802246 */
9999 -19031, /* B1 = -1.161560 */
10000 26287, /* B0 = 0.802246 */
10001 24195, /* A1 = -1.476746 */
10002 -32673, /* A2 = 0.997101 */
10003 2890, /* B2 = 0.088196 */
10004 -2151, /* B1 = -0.131317 */
10005 2890, /* B0 = 0.088196 */
10006 5, /* Internal filter scaling */
10007 159, /* Minimum in-band energy threshold */
10008 21, /* 21/32 in-band to broad-band ratio */
10009 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10010 },
10011 { /* f950_1400[] */
10012 18294, /* A1 = 1.116638 */
10013 -26962, /* A2 = -0.822845 */
10014 -2914, /* B2 = -0.088936 */
10015 0, /* B1 = 0 */
10016 2914, /* B0 = 0.088936 */
10017 14119, /* A1 = 0.861786 */
10018 -30227, /* A2 = -0.922455 */
10019 11466, /* B2 = 0.349945 */
10020 -2833, /* B1 = -0.172943 */
10021 11466, /* B0 = 0.349945 */
10022 23431, /* A1 = 1.430115 */
10023 -30828, /* A2 = -0.940796 */
10024 25331, /* B2 = 0.773071 */
10025 -20911, /* B1 = -1.276367 */
10026 25331, /* B0 = 0.773071 */
10027 7, /* Internal filter scaling */
10028 159, /* Minimum in-band energy threshold */
10029 21, /* 21/32 in-band to broad-band ratio */
10030 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10031 },
10032 { /* f975 */
10033 23521, /* A1 = -1.435608 */
10034 -32489, /* A2 = 0.991516 */
10035 -193, /* B2 = -0.005915 */
10036 0, /* B1 = 0.000000 */
10037 193, /* B0 = 0.005915 */
10038 23404, /* A1 = -1.428467 */
10039 -32655, /* A2 = 0.996582 */
10040 17740, /* B2 = 0.541412 */
10041 -12567, /* B1 = -0.767029 */
10042 17740, /* B0 = 0.541412 */
10043 23753, /* A1 = -1.449829 */
10044 -32657, /* A2 = 0.996613 */
10045 9090, /* B2 = 0.277405 */
10046 -6662, /* B1 = -0.406647 */
10047 9090, /* B0 = 0.277405 */
10048 5, /* Internal filter scaling */
10049 159, /* Minimum in-band energy threshold */
10050 21, /* 21/32 in-band to broad-band ratio */
10051 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10052 },
10053 { /* f1000 */
10054 23071, /* A1 = -1.408203 */
10055 -32489, /* A2 = 0.991516 */
10056 -293, /* B2 = -0.008965 */
10057 0, /* B1 = 0.000000 */
10058 293, /* B0 = 0.008965 */
10059 22951, /* A1 = -1.400818 */
10060 -32655, /* A2 = 0.996582 */
10061 5689, /* B2 = 0.173645 */
10062 -3951, /* B1 = -0.241150 */
10063 5689, /* B0 = 0.173645 */
10064 23307, /* A1 = -1.422607 */
10065 -32657, /* A2 = 0.996613 */
10066 18692, /* B2 = 0.570435 */
10067 -13447, /* B1 = -0.820770 */
10068 18692, /* B0 = 0.570435 */
10069 5, /* Internal filter scaling */
10070 159, /* Minimum in-band energy threshold */
10071 21, /* 21/32 in-band to broad-band ratio */
10072 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10073 },
10074 { /* f1020 */
10075 22701, /* A1 = -1.385620 */
10076 -32474, /* A2 = 0.991058 */
10077 -292, /* B2 = -0.008933 */
10078 0, /*163840 , B1 = 10.000000 */
10079 292, /* B0 = 0.008933 */
10080 22564, /* A1 = -1.377258 */
10081 -32655, /* A2 = 0.996552 */
10082 20756, /* B2 = 0.633423 */
10083 -14176, /* B1 = -0.865295 */
10084 20756, /* B0 = 0.633423 */
10085 22960, /* A1 = -1.401428 */
10086 -32657, /* A2 = 0.996613 */
10087 6520, /* B2 = 0.198990 */
10088 -4619, /* B1 = -0.281937 */
10089 6520, /* B0 = 0.198990 */
10090 5, /* Internal filter scaling */
10091 159, /* Minimum in-band energy threshold */
10092 21, /* 21/32 in-band to broad-band ratio */
10093 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10094 },
10095 { /* f1050 */
10096 22142, /* A1 = -1.351501 */
10097 -32474, /* A2 = 0.991058 */
10098 -147, /* B2 = -0.004493 */
10099 0, /* B1 = 0.000000 */
10100 147, /* B0 = 0.004493 */
10101 22000, /* A1 = -1.342834 */
10102 -32655, /* A2 = 0.996552 */
10103 15379, /* B2 = 0.469360 */
10104 -10237, /* B1 = -0.624847 */
10105 15379, /* B0 = 0.469360 */
10106 22406, /* A1 = -1.367554 */
10107 -32657, /* A2 = 0.996613 */
10108 17491, /* B2 = 0.533783 */
10109 -12096, /* B1 = -0.738312 */
10110 17491, /* B0 = 0.533783 */
10111 5, /* Internal filter scaling */
10112 159, /* Minimum in-band energy threshold */
10113 21, /* 21/32 in-band to broad-band ratio */
10114 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10115 },
10116 { /* f1100_1750[] */
10117 12973, /* A1 = 0.79184 */
10118 -24916, /* A2 = -0.760376 */
10119 6655, /* B2 = 0.203102 */
10120 367, /* B1 = 0.0224 */
10121 6657, /* B0 = 0.203171 */
10122 5915, /* A1 = 0.361053 */
10123 -29560, /* A2 = -0.90213 */
10124 -7777, /* B2 = -0.23735 */
10125 0, /* B1 = 0 */
10126 7777, /* B0 = 0.23735 */
10127 20510, /* A1 = 1.251892 */
10128 -30260, /* A2 = -0.923462 */
10129 26662, /* B2 = 0.81366 */
10130 -20573, /* B1 = -1.255737 */
10131 26668, /* B0 = 0.813843 */
10132 7, /* Internal filter scaling */
10133 159, /* Minimum in-band energy threshold */
10134 21, /* 21/32 in-band to broad-band ratio */
10135 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10136 },
10137 { /* f1140 */
10138 20392, /* A1 = -1.244629 */
10139 -32460, /* A2 = 0.990601 */
10140 -270, /* B2 = -0.008240 */
10141 0, /* B1 = 0.000000 */
10142 270, /* B0 = 0.008240 */
10143 20218, /* A1 = -1.234009 */
10144 -32655, /* A2 = 0.996582 */
10145 21337, /* B2 = 0.651154 */
10146 -13044, /* B1 = -0.796143 */
10147 21337, /* B0 = 0.651154 */
10148 20684, /* A1 = -1.262512 */
10149 -32657, /* A2 = 0.996643 */
10150 8572, /* B2 = 0.261612 */
10151 -5476, /* B1 = -0.334244 */
10152 8572, /* B0 = 0.261612 */
10153 5, /* Internal filter scaling */
10154 159, /* Minimum in-band energy threshold */
10155 21, /* 21/32 in-band to broad-band ratio */
10156 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10157 },
10158 { /* f1200 */
10159 19159, /* A1 = -1.169373 */
10160 -32456, /* A2 = 0.990509 */
10161 -335, /* B2 = -0.010252 */
10162 0, /* B1 = 0.000000 */
10163 335, /* B0 = 0.010252 */
10164 18966, /* A1 = -1.157593 */
10165 -32661, /* A2 = 0.996735 */
10166 6802, /* B2 = 0.207588 */
10167 -3900, /* B1 = -0.238098 */
10168 6802, /* B0 = 0.207588 */
10169 19467, /* A1 = -1.188232 */
10170 -32661, /* A2 = 0.996765 */
10171 25035, /* B2 = 0.764008 */
10172 -15049, /* B1 = -0.918579 */
10173 25035, /* B0 = 0.764008 */
10174 5, /* Internal filter scaling */
10175 159, /* Minimum in-band energy threshold */
10176 21, /* 21/32 in-band to broad-band ratio */
10177 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10178 },
10179 { /* f1209 */
10180 18976, /* A1 = -1.158264 */
10181 -32439, /* A2 = 0.989990 */
10182 -183, /* B2 = -0.005588 */
10183 0, /* B1 = 0.000000 */
10184 183, /* B0 = 0.005588 */
10185 18774, /* A1 = -1.145874 */
10186 -32650, /* A2 = 0.996429 */
10187 15468, /* B2 = 0.472076 */
10188 -8768, /* B1 = -0.535217 */
10189 15468, /* B0 = 0.472076 */
10190 19300, /* A1 = -1.177979 */
10191 -32652, /* A2 = 0.996490 */
10192 19840, /* B2 = 0.605499 */
10193 -11842, /* B1 = -0.722809 */
10194 19840, /* B0 = 0.605499 */
10195 5, /* Internal filter scaling */
10196 159, /* Minimum in-band energy threshold */
10197 21, /* 21/32 in-band to broad-band ratio */
10198 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10199 },
10200 { /* f1330 */
10201 16357, /* A1 = -0.998413 */
10202 -32368, /* A2 = 0.987793 */
10203 -217, /* B2 = -0.006652 */
10204 0, /* B1 = 0.000000 */
10205 217, /* B0 = 0.006652 */
10206 16107, /* A1 = -0.983126 */
10207 -32601, /* A2 = 0.994904 */
10208 11602, /* B2 = 0.354065 */
10209 -5555, /* B1 = -0.339111 */
10210 11602, /* B0 = 0.354065 */
10211 16722, /* A1 = -1.020630 */
10212 -32603, /* A2 = 0.994965 */
10213 15574, /* B2 = 0.475311 */
10214 -8176, /* B1 = -0.499069 */
10215 15574, /* B0 = 0.475311 */
10216 5, /* Internal filter scaling */
10217 159, /* Minimum in-band energy threshold */
10218 21, /* 21/32 in-band to broad-band ratio */
10219 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10220 },
10221 { /* f1336 */
10222 16234, /* A1 = -0.990875 */
10223 32404, /* A2 = -0.988922 */
10224 -193, /* B2 = -0.005908 */
10225 0, /* B1 = 0.000000 */
10226 193, /* B0 = 0.005908 */
10227 15986, /* A1 = -0.975769 */
10228 -32632, /* A2 = 0.995880 */
10229 18051, /* B2 = 0.550903 */
10230 -8658, /* B1 = -0.528473 */
10231 18051, /* B0 = 0.550903 */
10232 16591, /* A1 = -1.012695 */
10233 -32634, /* A2 = 0.995941 */
10234 15736, /* B2 = 0.480240 */
10235 -8125, /* B1 = -0.495926 */
10236 15736, /* B0 = 0.480240 */
10237 5, /* Internal filter scaling */
10238 159, /* Minimum in-band energy threshold */
10239 21, /* 21/32 in-band to broad-band ratio */
10240 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10241 },
10242 { /* f1366 */
10243 15564, /* A1 = -0.949982 */
10244 -32404, /* A2 = 0.988922 */
10245 -269, /* B2 = -0.008216 */
10246 0, /* B1 = 0.000000 */
10247 269, /* B0 = 0.008216 */
10248 15310, /* A1 = -0.934479 */
10249 -32632, /* A2 = 0.995880 */
10250 10815, /* B2 = 0.330063 */
10251 -4962, /* B1 = -0.302887 */
10252 10815, /* B0 = 0.330063 */
10253 15924, /* A1 = -0.971924 */
10254 -32634, /* A2 = 0.995941 */
10255 18880, /* B2 = 0.576172 */
10256 -9364, /* B1 = -0.571594 */
10257 18880, /* B0 = 0.576172 */
10258 5, /* Internal filter scaling */
10259 159, /* Minimum in-band energy threshold */
10260 21, /* 21/32 in-band to broad-band ratio */
10261 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10262 },
10263 { /* f1380 */
10264 15247, /* A1 = -0.930603 */
10265 -32397, /* A2 = 0.988708 */
10266 -244, /* B2 = -0.007451 */
10267 0, /* B1 = 0.000000 */
10268 244, /* B0 = 0.007451 */
10269 14989, /* A1 = -0.914886 */
10270 -32627, /* A2 = 0.995697 */
10271 18961, /* B2 = 0.578644 */
10272 -8498, /* B1 = -0.518707 */
10273 18961, /* B0 = 0.578644 */
10274 15608, /* A1 = -0.952667 */
10275 -32628, /* A2 = 0.995758 */
10276 11145, /* B2 = 0.340134 */
10277 -5430, /* B1 = -0.331467 */
10278 11145, /* B0 = 0.340134 */
10279 5, /* Internal filter scaling */
10280 159, /* Minimum in-band energy threshold */
10281 21, /* 21/32 in-band to broad-band ratio */
10282 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10283 },
10284 { /* f1400 */
10285 14780, /* A1 = -0.902130 */
10286 -32393, /* A2 = 0.988586 */
10287 -396, /* B2 = -0.012086 */
10288 0, /* B1 = 0.000000 */
10289 396, /* B0 = 0.012086 */
10290 14510, /* A1 = -0.885651 */
10291 -32630, /* A2 = 0.995819 */
10292 6326, /* B2 = 0.193069 */
10293 -2747, /* B1 = -0.167671 */
10294 6326, /* B0 = 0.193069 */
10295 15154, /* A1 = -0.924957 */
10296 -32632, /* A2 = 0.995850 */
10297 23235, /* B2 = 0.709076 */
10298 -10983, /* B1 = -0.670380 */
10299 23235, /* B0 = 0.709076 */
10300 5, /* Internal filter scaling */
10301 159, /* Minimum in-band energy threshold */
10302 21, /* 21/32 in-band to broad-band ratio */
10303 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10304 },
10305 { /* f1477 */
10306 13005, /* A1 = -0.793793 */
10307 -32368, /* A2 = 0.987823 */
10308 -500, /* B2 = -0.015265 */
10309 0, /* B1 = 0.000000 */
10310 500, /* B0 = 0.015265 */
10311 12708, /* A1 = -0.775665 */
10312 -32615, /* A2 = 0.995331 */
10313 11420, /* B2 = 0.348526 */
10314 -4306, /* B1 = -0.262833 */
10315 11420, /* B0 = 0.348526 */
10316 13397, /* A1 = -0.817688 */
10317 -32615, /* A2 = 0.995361 */
10318 9454, /* B2 = 0.288528 */
10319 -3981, /* B1 = -0.243027 */
10320 9454, /* B0 = 0.288528 */
10321 5, /* Internal filter scaling */
10322 159, /* Minimum in-band energy threshold */
10323 21, /* 21/32 in-band to broad-band ratio */
10324 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10325 },
10326 { /* f1600 */
10327 10046, /* A1 = -0.613190 */
10328 -32331, /* A2 = 0.986694 */
10329 -455, /* B2 = -0.013915 */
10330 0, /* B1 = 0.000000 */
10331 455, /* B0 = 0.013915 */
10332 9694, /* A1 = -0.591705 */
10333 -32601, /* A2 = 0.994934 */
10334 6023, /* B2 = 0.183815 */
10335 -1708, /* B1 = -0.104279 */
10336 6023, /* B0 = 0.183815 */
10337 10478, /* A1 = -0.639587 */
10338 -32603, /* A2 = 0.994965 */
10339 22031, /* B2 = 0.672333 */
10340 -7342, /* B1 = -0.448151 */
10341 22031, /* B0 = 0.672333 */
10342 5, /* Internal filter scaling */
10343 159, /* Minimum in-band energy threshold */
10344 21, /* 21/32 in-band to broad-band ratio */
10345 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10346 },
10347 { /* f1633_1638[] */
10348 9181, /* A1 = 0.560394 */
10349 -32256, /* A2 = -0.984375 */
10350 -556, /* B2 = -0.016975 */
10351 0, /* B1 = 0 */
10352 556, /* B0 = 0.016975 */
10353 8757, /* A1 = 0.534515 */
10354 -32574, /* A2 = -0.99408 */
10355 8443, /* B2 = 0.25769 */
10356 -2135, /* B1 = -0.130341 */
10357 8443, /* B0 = 0.25769 */
10358 9691, /* A1 = 0.591522 */
10359 -32574, /* A2 = -0.99411 */
10360 15446, /* B2 = 0.471375 */
10361 -4809, /* B1 = -0.293579 */
10362 15446, /* B0 = 0.471375 */
10363 7, /* Internal filter scaling */
10364 159, /* Minimum in-band energy threshold */
10365 21, /* 21/32 in-band to broad-band ratio */
10366 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10367 },
10368 { /* f1800 */
10369 5076, /* A1 = -0.309875 */
10370 -32304, /* A2 = 0.985840 */
10371 -508, /* B2 = -0.015503 */
10372 0, /* B1 = 0.000000 */
10373 508, /* B0 = 0.015503 */
10374 4646, /* A1 = -0.283600 */
10375 -32605, /* A2 = 0.995026 */
10376 6742, /* B2 = 0.205780 */
10377 -878, /* B1 = -0.053635 */
10378 6742, /* B0 = 0.205780 */
10379 5552, /* A1 = -0.338928 */
10380 -32605, /* A2 = 0.995056 */
10381 23667, /* B2 = 0.722260 */
10382 -4297, /* B1 = -0.262329 */
10383 23667, /* B0 = 0.722260 */
10384 5, /* Internal filter scaling */
10385 159, /* Minimum in-band energy threshold */
10386 21, /* 21/32 in-band to broad-band ratio */
10387 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10388 },
10389 { /* f1860 */
10390 3569, /* A1 = -0.217865 */
10391 -32292, /* A2 = 0.985504 */
10392 -239, /* B2 = -0.007322 */
10393 0, /* B1 = 0.000000 */
10394 239, /* B0 = 0.007322 */
10395 3117, /* A1 = -0.190277 */
10396 -32603, /* A2 = 0.994965 */
10397 18658, /* B2 = 0.569427 */
10398 -1557, /* B1 = -0.095032 */
10399 18658, /* B0 = 0.569427 */
10400 4054, /* A1 = -0.247437 */
10401 -32603, /* A2 = 0.994965 */
10402 18886, /* B2 = 0.576385 */
10403 -2566, /* B1 = -0.156647 */
10404 18886, /* B0 = 0.576385 */
10405 5, /* Internal filter scaling */
10406 159, /* Minimum in-band energy threshold */
10407 21, /* 21/32 in-band to broad-band ratio */
10408 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10409 },
10410 };
10411 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10412 {
10413 unsigned short cmd;
10414 int cnt, max;
10415
10416 if (jf->filter > 3) {
10417 return -1;
10418 }
10419 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10420
10421 return -1;
10422 if (!jf->enable) {
10423 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10424
10425 return -1;
10426 else
10427 return 0;
10428 } else {
10429 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10430
10431 return -1;
10432 /* Select the filter (f0 - f3) to use. */
10433 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10434 return -1;
10435 }
10436 if (jf->freq < 12 && jf->freq > 3) {
10437 /* Select the frequency for the selected filter. */
10438 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10439 return -1;
10440 } else if (jf->freq > 11) {
10441 /* We need to load a programmable filter set for undefined */
10442 /* frequencies. So we will point the filter to a programmable set. */
10443 /* Since there are only 4 filters and 4 programmable sets, we will */
10444 /* just point the filter to the same number set and program it for the */
10445 /* frequency we want. */
10446 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10447 return -1;
10448 if (j->ver.low != 0x12) {
10449 cmd = 0x515B;
10450 max = 19;
10451 } else {
10452 cmd = 0x515E;
10453 max = 15;
10454 }
10455 if (ixj_WriteDSPCommand(cmd, j))
10456 return -1;
10457 for (cnt = 0; cnt < max; cnt++) {
10458 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10459 return -1;
10460 }
10461 }
10462 j->filter_en[jf->filter] = jf->enable;
10463 return 0;
10464 }
10465
10466 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10467 {
10468 unsigned short cmd;
10469 int cnt, max;
10470 if (jfr->filter > 3) {
10471 return -1;
10472 }
10473 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10474 return -1;
10475
10476 if (!jfr->enable) {
10477 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10478 return -1;
10479 else
10480 return 0;
10481 } else {
10482 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10483 return -1;
10484 /* Select the filter (f0 - f3) to use. */
10485 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10486 return -1;
10487 }
10488 /* We need to load a programmable filter set for undefined */
10489 /* frequencies. So we will point the filter to a programmable set. */
10490 /* Since there are only 4 filters and 4 programmable sets, we will */
10491 /* just point the filter to the same number set and program it for the */
10492 /* frequency we want. */
10493 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10494 return -1;
10495 if (j->ver.low != 0x12) {
10496 cmd = 0x515B;
10497 max = 19;
10498 } else {
10499 cmd = 0x515E;
10500 max = 15;
10501 }
10502 if (ixj_WriteDSPCommand(cmd, j))
10503 return -1;
10504 for (cnt = 0; cnt < max; cnt++) {
10505 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10506 return -1;
10507 }
10508 j->filter_en[jfr->filter] = jfr->enable;
10509 return 0;
10510 }
10511
10512 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10513 {
10514 int freq0, freq1;
10515 unsigned short data;
10516 if (ti->freq0) {
10517 freq0 = ti->freq0;
10518 } else {
10519 freq0 = 0x7FFF;
10520 }
10521
10522 if (ti->freq1) {
10523 freq1 = ti->freq1;
10524 } else {
10525 freq1 = 0x7FFF;
10526 }
10527
10528 if(ti->tone_index > 12 && ti->tone_index < 28)
10529 {
10530 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10531 return -1;
10532 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10533 return -1;
10534 data = freq0;
10535 if (ixj_WriteDSPCommand(data, j))
10536 return -1;
10537 data = freq1;
10538 if (ixj_WriteDSPCommand(data, j))
10539 return -1;
10540 }
10541 return freq0;
10542 }
10543
Linux with added FPC-III support