File: /usr/src/linux/drivers/telephony/ixj.c
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 *
27 * More information about the hardware related to this driver can be found
28 * at our website: http://www.quicknet.net
29 *
30 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
31 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
32 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
33 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
36 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
37 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
38 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
39 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
40 *
41 ***************************************************************************/
42
43 static char ixj_c_rcsid[] = "$Id: ixj.c,v 4.7 2001/08/13 06:19:33 craigs Exp $";
44 static char ixj_c_revision[] = "$Revision: 4.7 $";
45
46 /*
47 * $Log: ixj.c,v $
48 * Revision 4.7 2001/08/13 06:19:33 craigs
49 * Added additional changes from Alan Cox and John Anderson for
50 * 2.2 to 2.4 cleanup and bounds checking
51 *
52 * Revision 4.6 2001/08/13 01:05:05 craigs
53 * Really fixed PHONE_QUERY_CODEC problem this time
54 *
55 * Revision 4.5 2001/08/13 00:11:03 craigs
56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57 *
58 * Revision 4.4 2001/08/07 07:58:12 craigs
59 * Changed back to three digit version numbers
60 * Added tagbuild target to allow automatic and easy tagging of versions
61 *
62 * Revision 4.3 2001/08/07 07:24:47 craigs
63 * Added ixj-ver.h to allow easy configuration management of driver
64 * Added display of version number in /prox/ixj
65 *
66 * Revision 4.2 2001/08/06 07:07:19 craigs
67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68 * behaviour of returning int rather than short *
69 *
70 * Revision 4.1 2001/08/05 00:17:37 craigs
71 * More changes for correct PCMCIA installation
72 * Start of changes for backward Linux compatibility
73 *
74 * Revision 4.0 2001/08/04 12:33:12 craigs
75 * New version using GNU autoconf
76 *
77 * Revision 3.105 2001/07/20 23:14:32 eokerson
78 * More work on CallerID generation when using ring cadences.
79 *
80 * Revision 3.104 2001/07/06 01:33:55 eokerson
81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
82 *
83 * Revision 3.103 2001/07/05 19:20:16 eokerson
84 * Updated HOWTO
85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86 *
87 * Revision 3.102 2001/07/03 23:51:21 eokerson
88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
89 *
90 * Revision 3.101 2001/07/02 19:26:56 eokerson
91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92 *
93 * Revision 3.100 2001/07/02 19:18:27 eokerson
94 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96 * Fixed speaker mode on Internet LineJACK.
97 *
98 * Revision 3.99 2001/05/09 14:11:16 eokerson
99 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
100 *
101 * Revision 3.98 2001/05/08 19:55:33 eokerson
102 * Fixed POTS hookstate detection while it is connected to PSTN port.
103 *
104 * Revision 3.97 2001/05/08 00:01:04 eokerson
105 * Fixed kernel oops when sending caller ID data.
106 *
107 * Revision 3.96 2001/05/04 23:09:30 eokerson
108 * Now uses one kernel timer for each card, instead of one for the entire driver.
109 *
110 * Revision 3.95 2001/04/25 22:06:47 eokerson
111 * Fixed squawking at beginning of some G.723.1 calls.
112 *
113 * Revision 3.94 2001/04/03 23:42:00 eokerson
114 * Added linear volume ioctls
115 * Added raw filter load ioctl
116 *
117 * Revision 3.93 2001/02/27 01:00:06 eokerson
118 * Fixed blocking in CallerID.
119 * Reduced size of ixj structure for smaller driver footprint.
120 *
121 * Revision 3.92 2001/02/20 22:02:59 eokerson
122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123 * Improved PSTN ring detection.
124 * Fixed wink generation on POTS ports.
125 *
126 * Revision 3.91 2001/02/13 00:55:44 eokerson
127 * Turn AEC back on after changing frame sizes.
128 *
129 * Revision 3.90 2001/02/12 16:42:00 eokerson
130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131 *
132 * Revision 3.89 2001/02/12 15:41:16 eokerson
133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
134 *
135 * Revision 3.88 2001/02/05 23:25:42 eokerson
136 * Fixed lockup bugs with deregister.
137 *
138 * Revision 3.87 2001/01/29 21:00:39 eokerson
139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
140 * Updated copyright date.
141 *
142 * Revision 3.86 2001/01/23 23:53:46 eokerson
143 * Fixes to G.729 compatibility.
144 *
145 * Revision 3.85 2001/01/23 21:30:36 eokerson
146 * Added verbage about cards supported.
147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148 *
149 * Revision 3.84 2001/01/22 23:32:10 eokerson
150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
151 *
152 * Revision 3.83 2001/01/19 14:51:41 eokerson
153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154 *
155 * Revision 3.82 2001/01/19 00:34:49 eokerson
156 * Added verbosity to write overlap errors.
157 *
158 * Revision 3.81 2001/01/18 23:56:54 eokerson
159 * Fixed PSTN line test functions.
160 *
161 * Revision 3.80 2001/01/18 22:29:27 eokerson
162 * Updated AEC/AGC values for different cards.
163 *
164 * Revision 3.79 2001/01/17 02:58:54 eokerson
165 * Fixed AEC reset after Caller ID.
166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167 *
168 * Revision 3.78 2001/01/16 19:43:09 eokerson
169 * Added support for Linux 2.4.x kernels.
170 *
171 * Revision 3.77 2001/01/09 04:00:52 eokerson
172 * Linetest will now test the line, even if it has previously succeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246 #include "ixj-ver.h"
247
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251
252 #include <linux/module.h>
253
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/mm.h>
261 #include <linux/ioport.h>
262 #include <linux/interrupt.h>
263 #include <linux/tqueue.h>
264 #include <linux/proc_fs.h>
265 #include <linux/poll.h>
266 #include <linux/timer.h>
267 #include <linux/delay.h>
268 #include <linux/pci.h>
269
270 #include <asm/io.h>
271 #include <asm/segment.h>
272 #include <asm/uaccess.h>
273
274 #include <linux/isapnp.h>
275
276 #include "ixj.h"
277
278 #define TYPE(dev) (MINOR(dev) >> 4)
279 #define NUM(dev) (MINOR(dev) & 0xf)
280
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 MODULE_PARM(ixjdebug, "i");
286
287 /************************************************************************
288 *
289 * ixjdebug meanings are now bit mapped instead of level based
290 * Values can be or'ed together to turn on multiple messages
291 *
292 * bit 0 (0x0001) = any failure
293 * bit 1 (0x0002) = general messages
294 * bit 2 (0x0004) = POTS ringing related
295 * bit 3 (0x0008) = PSTN events
296 * bit 4 (0x0010) = PSTN Cadence state details
297 * bit 5 (0x0020) = Tone detection triggers
298 * bit 6 (0x0040) = Tone detection cadence details
299 * bit 7 (0x0080) = ioctl tracking
300 * bit 8 (0x0100) = signal tracking
301 * bit 9 (0x0200) = CallerID generation details
302 *
303 ************************************************************************/
304
305 #ifdef IXJ_DYN_ALLOC
306
307 static IXJ *ixj[IXJMAX];
308 #define get_ixj(b) ixj[(b)]
309
310 /*
311 * Allocate a free IXJ device
312 */
313
314 static IXJ *ixj_alloc()
315 {
316 for(cnt=0; cnt<IXJMAX; cnt++)
317 {
318 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
319 {
320 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
321 if (j == NULL)
322 return NULL;
323 ixj[cnt] = j;
324 return j;
325 }
326 }
327 return NULL;
328 }
329
330 static void ixj_fsk_free(IXJ *j)
331 {
332 if(j->fskdata != NULL) {
333 kfree(j->fskdata);
334 j->fskdata = NULL;
335 }
336 }
337
338 static void ixj_fsk_alloc(IXJ *j)
339 {
340 if(!j->fskdata) {
341 j->fskdata = kmalloc(8000, GFP_KERNEL);
342 if (!j->fskdata) {
343 if(ixjdebug & 0x0200) {
344 printk("IXJ phone%d - allocate failed\n", j->board);
345 }
346 return;
347 } else {
348 j->fsksize = 8000;
349 if(ixjdebug & 0x0200) {
350 printk("IXJ phone%d - allocate succeded\n", j->board);
351 }
352 }
353 }
354 }
355
356 #else
357
358 static IXJ ixj[IXJMAX];
359 #define get_ixj(b) (&ixj[(b)])
360
361 /*
362 * Allocate a free IXJ device
363 */
364
365 static IXJ *ixj_alloc(void)
366 {
367 int cnt;
368 for(cnt=0; cnt<IXJMAX; cnt++)
369 {
370 if(!ixj[cnt].DSPbase)
371 {
372 return &ixj[cnt];
373 }
374 }
375 return NULL;
376 }
377
378 static inline void ixj_fsk_free(IXJ *j) {;}
379
380 static inline void ixj_fsk_alloc(IXJ *j)
381 {
382 j->fsksize = 8000;
383 }
384
385 #endif
386
387 #ifdef PERFMON_STATS
388 #define ixj_perfmon(x) ((x)++)
389 #else
390 #deifne ixj_perfmon(x) do {} while(0);
391 #endif
392
393 static int ixj_convert_loaded;
394
395 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
396
397 /************************************************************************
398 *
399 * These are function definitions to allow external modules to register
400 * enhanced functionality call backs.
401 *
402 ************************************************************************/
403
404 static int Stub(IXJ * J, unsigned long arg)
405 {
406 return 0;
407 }
408
409 static IXJ_REGFUNC ixj_DownloadG729 = &Stub;
410 static IXJ_REGFUNC ixj_DownloadTS85 = &Stub;
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415 static IXJ_REGFUNC ixj_PreIoctl = &Stub;
416 static IXJ_REGFUNC ixj_PostIoctl = &Stub;
417
418 static void ixj_read_frame(IXJ *j);
419 static void ixj_write_frame(IXJ *j);
420 static void ixj_init_timer(IXJ *j);
421 static void ixj_add_timer(IXJ * j);
422 static void ixj_timeout(unsigned long ptr);
423 static int read_filters(IXJ *j);
424 static int LineMonitor(IXJ *j);
425 static int ixj_fasync(int fd, struct file *, int mode);
426 static int ixj_set_port(IXJ *j, int arg);
427 static int ixj_set_pots(IXJ *j, int arg);
428 static int ixj_hookstate(IXJ *j);
429 static int ixj_record_start(IXJ *j);
430 static void ixj_record_stop(IXJ *j);
431 static void set_rec_volume(IXJ *j, int volume);
432 static int get_rec_volume(IXJ *j);
433 static int set_rec_codec(IXJ *j, int rate);
434 static void ixj_vad(IXJ *j, int arg);
435 static int ixj_play_start(IXJ *j);
436 static void ixj_play_stop(IXJ *j);
437 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
438 static int ixj_set_tone_off(unsigned short, IXJ *j);
439 static int ixj_play_tone(IXJ *j, char tone);
440 static void ixj_aec_start(IXJ *j, int level);
441 static int idle(IXJ *j);
442 static void ixj_ring_on(IXJ *j);
443 static void ixj_ring_off(IXJ *j);
444 static void aec_stop(IXJ *j);
445 static void ixj_ringback(IXJ *j);
446 static void ixj_busytone(IXJ *j);
447 static void ixj_dialtone(IXJ *j);
448 static void ixj_cpt_stop(IXJ *j);
449 static char daa_int_read(IXJ *j);
450 static char daa_CR_read(IXJ *j, int cr);
451 static int daa_set_mode(IXJ *j, int mode);
452 static int ixj_linetest(IXJ *j);
453 static int ixj_daa_write(IXJ *j);
454 static int ixj_daa_cid_read(IXJ *j);
455 static void DAA_Coeff_US(IXJ *j);
456 static void DAA_Coeff_UK(IXJ *j);
457 static void DAA_Coeff_France(IXJ *j);
458 static void DAA_Coeff_Germany(IXJ *j);
459 static void DAA_Coeff_Australia(IXJ *j);
460 static void DAA_Coeff_Japan(IXJ *j);
461 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
462 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
463 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
464 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE * cp);
465 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE * cp);
466 /* Serial Control Interface funtions */
467 static int SCI_Control(IXJ *j, int control);
468 static int SCI_Prepare(IXJ *j);
469 static int SCI_WaitHighSCI(IXJ *j);
470 static int SCI_WaitLowSCI(IXJ *j);
471 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
472 static int ixj_PCcontrol_wait(IXJ *j);
473 static void ixj_pre_cid(IXJ *j);
474 static void ixj_write_cid(IXJ *j);
475 static void ixj_write_cid_bit(IXJ *j, int bit);
476 static int set_base_frame(IXJ *j, int size);
477 static int set_play_codec(IXJ *j, int rate);
478 static void set_rec_depth(IXJ *j, int depth);
479 static int ixj_mixer(long val, IXJ *j);
480
481 /************************************************************************
482 CT8020/CT8021 Host Programmers Model
483 Host address Function Access
484 DSPbase +
485 0-1 Aux Software Status Register (reserved) Read Only
486 2-3 Software Status Register Read Only
487 4-5 Aux Software Control Register (reserved) Read Write
488 6-7 Software Control Register Read Write
489 8-9 Hardware Status Register Read Only
490 A-B Hardware Control Register Read Write
491 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
492 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
493 ************************************************************************/
494
495 static inline void ixj_read_HSR(IXJ *j)
496 {
497 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
498 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
499 }
500
501 static inline int IsControlReady(IXJ *j)
502 {
503 ixj_read_HSR(j);
504 return j->hsr.bits.controlrdy ? 1 : 0;
505 }
506
507 static inline int IsPCControlReady(IXJ *j)
508 {
509 j->pccr1.byte = inb_p(j->XILINXbase + 3);
510 return j->pccr1.bits.crr ? 1 : 0;
511 }
512
513 static inline int IsStatusReady(IXJ *j)
514 {
515 ixj_read_HSR(j);
516 return j->hsr.bits.statusrdy ? 1 : 0;
517 }
518
519 static inline int IsRxReady(IXJ *j)
520 {
521 ixj_read_HSR(j);
522 ixj_perfmon(j->rxreadycheck);
523 return j->hsr.bits.rxrdy ? 1 : 0;
524 }
525
526 static inline int IsTxReady(IXJ *j)
527 {
528 ixj_read_HSR(j);
529 ixj_perfmon(j->txreadycheck);
530 return j->hsr.bits.txrdy ? 1 : 0;
531 }
532
533 static inline void set_play_volume(IXJ *j, int volume)
534 {
535 if (ixjdebug & 0x0002)
536 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
537 ixj_WriteDSPCommand(0xCF02, j);
538 ixj_WriteDSPCommand(volume, j);
539 }
540
541 static int set_play_volume_linear(IXJ *j, int volume)
542 {
543 int newvolume, dspplaymax;
544
545 if (ixjdebug & 0x0002)
546 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
547 if(volume > 100 || volume < 0) {
548 return -1;
549 }
550
551 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
552 switch (j->cardtype) {
553 case QTI_PHONEJACK:
554 dspplaymax = 0x380;
555 break;
556 case QTI_LINEJACK:
557 if(j->port == PORT_PSTN) {
558 dspplaymax = 0x48;
559 } else {
560 dspplaymax = 0x100;
561 }
562 break;
563 case QTI_PHONEJACK_LITE:
564 dspplaymax = 0x380;
565 break;
566 case QTI_PHONEJACK_PCI:
567 dspplaymax = 0x6C;
568 break;
569 case QTI_PHONECARD:
570 dspplaymax = 0x50;
571 break;
572 default:
573 return -1;
574 }
575 newvolume = (dspplaymax * volume) / 100;
576 set_play_volume(j, newvolume);
577 return 0;
578 }
579
580 static inline void set_play_depth(IXJ *j, int depth)
581 {
582 if (depth > 60)
583 depth = 60;
584 if (depth < 0)
585 depth = 0;
586 ixj_WriteDSPCommand(0x5280 + depth, j);
587 }
588
589 static inline int get_play_volume(IXJ *j)
590 {
591 ixj_WriteDSPCommand(0xCF00, j);
592 return j->ssr.high << 8 | j->ssr.low;
593 }
594
595 static int get_play_volume_linear(IXJ *j)
596 {
597 int volume, newvolume, dspplaymax;
598
599 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
600 switch (j->cardtype) {
601 case QTI_PHONEJACK:
602 dspplaymax = 0x380;
603 break;
604 case QTI_LINEJACK:
605 if(j->port == PORT_PSTN) {
606 dspplaymax = 0x48;
607 } else {
608 dspplaymax = 0x100;
609 }
610 break;
611 case QTI_PHONEJACK_LITE:
612 dspplaymax = 0x380;
613 break;
614 case QTI_PHONEJACK_PCI:
615 dspplaymax = 0x6C;
616 break;
617 case QTI_PHONECARD:
618 dspplaymax = 100;
619 break;
620 default:
621 return -1;
622 }
623 volume = get_play_volume(j);
624 newvolume = (volume * 100) / dspplaymax;
625 if(newvolume > 100)
626 newvolume = 100;
627 return newvolume;
628 }
629
630 static inline BYTE SLIC_GetState(IXJ *j)
631 {
632 if (j->cardtype == QTI_PHONECARD) {
633 j->pccr1.byte = 0;
634 j->psccr.bits.dev = 3;
635 j->psccr.bits.rw = 1;
636 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
637 ixj_PCcontrol_wait(j);
638 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
639 ixj_PCcontrol_wait(j);
640 if (j->pslic.bits.powerdown)
641 return PLD_SLIC_STATE_OC;
642 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
643 return PLD_SLIC_STATE_ACTIVE;
644 else
645 return PLD_SLIC_STATE_RINGING;
646 } else {
647 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
648 }
649 return j->pld_slicr.bits.state;
650 }
651
652 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
653 {
654 BOOL fRetVal = FALSE;
655
656 if (j->cardtype == QTI_PHONECARD) {
657 if (j->flags.pcmciasct) {
658 switch (byState) {
659 case PLD_SLIC_STATE_TIPOPEN:
660 case PLD_SLIC_STATE_OC:
661 j->pslic.bits.powerdown = 1;
662 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
663 fRetVal = TRUE;
664 break;
665 case PLD_SLIC_STATE_RINGING:
666 if (j->readers || j->writers) {
667 j->pslic.bits.powerdown = 0;
668 j->pslic.bits.ring0 = 1;
669 j->pslic.bits.ring1 = 0;
670 fRetVal = TRUE;
671 }
672 break;
673 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
674
675 case PLD_SLIC_STATE_STANDBY:
676 case PLD_SLIC_STATE_ACTIVE:
677 if (j->readers || j->writers) {
678 j->pslic.bits.powerdown = 0;
679 } else {
680 j->pslic.bits.powerdown = 1;
681 }
682 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
683 fRetVal = TRUE;
684 break;
685 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
686
687 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
688
689 default:
690 fRetVal = FALSE;
691 break;
692 }
693 j->psccr.bits.dev = 3;
694 j->psccr.bits.rw = 0;
695 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
696 ixj_PCcontrol_wait(j);
697 }
698 } else {
699 /* Set the C1, C2, C3 & B2EN signals. */
700 switch (byState) {
701 case PLD_SLIC_STATE_OC:
702 j->pld_slicw.bits.c1 = 0;
703 j->pld_slicw.bits.c2 = 0;
704 j->pld_slicw.bits.c3 = 0;
705 j->pld_slicw.bits.b2en = 0;
706 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
707 fRetVal = TRUE;
708 break;
709 case PLD_SLIC_STATE_RINGING:
710 j->pld_slicw.bits.c1 = 1;
711 j->pld_slicw.bits.c2 = 0;
712 j->pld_slicw.bits.c3 = 0;
713 j->pld_slicw.bits.b2en = 1;
714 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
715 fRetVal = TRUE;
716 break;
717 case PLD_SLIC_STATE_ACTIVE:
718 j->pld_slicw.bits.c1 = 0;
719 j->pld_slicw.bits.c2 = 1;
720 j->pld_slicw.bits.c3 = 0;
721 j->pld_slicw.bits.b2en = 0;
722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
723 fRetVal = TRUE;
724 break;
725 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
726
727 j->pld_slicw.bits.c1 = 1;
728 j->pld_slicw.bits.c2 = 1;
729 j->pld_slicw.bits.c3 = 0;
730 j->pld_slicw.bits.b2en = 0;
731 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
732 fRetVal = TRUE;
733 break;
734 case PLD_SLIC_STATE_TIPOPEN:
735 j->pld_slicw.bits.c1 = 0;
736 j->pld_slicw.bits.c2 = 0;
737 j->pld_slicw.bits.c3 = 1;
738 j->pld_slicw.bits.b2en = 0;
739 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
740 fRetVal = TRUE;
741 break;
742 case PLD_SLIC_STATE_STANDBY:
743 j->pld_slicw.bits.c1 = 1;
744 j->pld_slicw.bits.c2 = 0;
745 j->pld_slicw.bits.c3 = 1;
746 j->pld_slicw.bits.b2en = 1;
747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
748 fRetVal = TRUE;
749 break;
750 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
751
752 j->pld_slicw.bits.c1 = 0;
753 j->pld_slicw.bits.c2 = 1;
754 j->pld_slicw.bits.c3 = 1;
755 j->pld_slicw.bits.b2en = 0;
756 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
757 fRetVal = TRUE;
758 break;
759 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
760
761 j->pld_slicw.bits.c1 = 1;
762 j->pld_slicw.bits.c2 = 1;
763 j->pld_slicw.bits.c3 = 1;
764 j->pld_slicw.bits.b2en = 0;
765 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
766 fRetVal = TRUE;
767 break;
768 default:
769 fRetVal = FALSE;
770 break;
771 }
772 }
773
774 return fRetVal;
775 }
776
777 static int ixj_wink(IXJ *j)
778 {
779 BYTE slicnow;
780
781 slicnow = SLIC_GetState(j);
782
783 j->pots_winkstart = jiffies;
784 SLIC_SetState(PLD_SLIC_STATE_OC, j);
785
786 while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
787 set_current_state(TASK_INTERRUPTIBLE);
788 schedule_timeout(1);
789 }
790
791 SLIC_SetState(slicnow, j);
792 return 0;
793 }
794
795 static int ixj_register(int index, IXJ_REGFUNC regfunc)
796 {
797 int cnt;
798 int retval = 0;
799 switch (index) {
800 case G729LOADER:
801 ixj_DownloadG729 = regfunc;
802 for (cnt = 0; cnt < IXJMAX; cnt++) {
803 IXJ *j = get_ixj(cnt);
804 while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
805 set_current_state(TASK_INTERRUPTIBLE);
806 schedule_timeout(1);
807 }
808 ixj_DownloadG729(j, 0L);
809 clear_bit(cnt, &j->busyflags);
810 }
811 break;
812 case TS85LOADER:
813 ixj_DownloadTS85 = regfunc;
814 for (cnt = 0; cnt < IXJMAX; cnt++) {
815 IXJ *j = get_ixj(cnt);
816 while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
817 set_current_state(TASK_INTERRUPTIBLE);
818 schedule_timeout(1);
819 }
820 ixj_DownloadTS85(j, 0L);
821 clear_bit(cnt, &j->busyflags);
822 }
823 break;
824 case PRE_READ:
825 ixj_PreRead = regfunc;
826 break;
827 case POST_READ:
828 ixj_PostRead = regfunc;
829 break;
830 case PRE_WRITE:
831 ixj_PreWrite = regfunc;
832 break;
833 case POST_WRITE:
834 ixj_PostWrite = regfunc;
835 break;
836 case PRE_IOCTL:
837 ixj_PreIoctl = regfunc;
838 break;
839 case POST_IOCTL:
840 ixj_PostIoctl = regfunc;
841 break;
842 default:
843 retval = 1;
844 }
845 return retval;
846 }
847
848 EXPORT_SYMBOL(ixj_register);
849
850 static int ixj_unregister(int index)
851 {
852 int retval = 0;
853 switch (index) {
854 case G729LOADER:
855 ixj_DownloadG729 = &Stub;
856 break;
857 case TS85LOADER:
858 ixj_DownloadTS85 = &Stub;
859 break;
860 case PRE_READ:
861 ixj_PreRead = &Stub;
862 break;
863 case POST_READ:
864 ixj_PostRead = &Stub;
865 break;
866 case PRE_WRITE:
867 ixj_PreWrite = &Stub;
868 break;
869 case POST_WRITE:
870 ixj_PostWrite = &Stub;
871 break;
872 case PRE_IOCTL:
873 ixj_PreIoctl = &Stub;
874 break;
875 case POST_IOCTL:
876 ixj_PostIoctl = &Stub;
877 break;
878 default:
879 retval = 1;
880 }
881 return retval;
882 }
883
884 EXPORT_SYMBOL(ixj_unregister);
885
886 static void ixj_init_timer(IXJ *j)
887 {
888 init_timer(&j->timer);
889 j->timer.function = ixj_timeout;
890 j->timer.data = (unsigned long)j;
891 }
892
893 static void ixj_add_timer(IXJ *j)
894 {
895 j->timer.expires = jiffies + (hertz / samplerate);
896 add_timer(&j->timer);
897 }
898
899 static void ixj_tone_timeout(IXJ *j)
900 {
901 IXJ_TONE ti;
902
903 j->tone_state++;
904 if (j->tone_state == 3) {
905 j->tone_state = 0;
906 if (j->cadence_t) {
907 j->tone_cadence_state++;
908 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
909 switch (j->cadence_t->termination) {
910 case PLAY_ONCE:
911 ixj_cpt_stop(j);
912 break;
913 case REPEAT_LAST_ELEMENT:
914 j->tone_cadence_state--;
915 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
916 break;
917 case REPEAT_ALL:
918 j->tone_cadence_state = 0;
919 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
920 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
921 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
922 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
923 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
924 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
925 ixj_init_tone(j, &ti);
926 }
927 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
928 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
929 ixj_play_tone(j, j->cadence_t->ce[0].index);
930 break;
931 }
932 } else {
933 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
934 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
935 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
936 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
937 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
938 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
939 ixj_init_tone(j, &ti);
940 }
941 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
942 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
943 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
944 }
945 }
946 }
947 }
948
949 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
950 {
951 if(j->ixj_signals[event]) {
952 if(ixjdebug & 0x0100)
953 printk("Sending signal for event %d\n", event);
954 /* Send apps notice of change */
955 /* see config.h for macro definition */
956 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
957 }
958 }
959
960 static void ixj_pstn_state(IXJ *j)
961 {
962 int var;
963 union XOPXR0 XR0, daaint;
964
965 var = 10;
966
967 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
968 daaint.reg = 0;
969 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
970
971 j->pld_scrr.byte = inb_p(j->XILINXbase);
972 if (j->pld_scrr.bits.daaflag) {
973 daa_int_read(j);
974 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
975 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
976 daaint.bitreg.RING = 1;
977 if(ixjdebug & 0x0008) {
978 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
979 }
980 } else {
981 daa_set_mode(j, SOP_PU_RESET);
982 }
983 }
984 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
985 daaint.bitreg.Caller_ID = 1;
986 j->pstn_cid_intr = 1;
987 j->pstn_cid_received = jiffies;
988 if(ixjdebug & 0x0008) {
989 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
990 }
991 }
992 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
993 daaint.bitreg.Cadence = 1;
994 if(ixjdebug & 0x0008) {
995 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
996 }
997 }
998 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
999 daaint.bitreg.VDD_OK = 1;
1000 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
1001 }
1002 }
1003 daa_CR_read(j, 1);
1004 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
1005 daaint.bitreg.RMR = 1;
1006 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
1007 if(ixjdebug & 0x0008) {
1008 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
1009 }
1010 j->pstn_prev_rmr = j->pstn_last_rmr;
1011 j->pstn_last_rmr = jiffies;
1012 }
1013 switch(j->daa_mode) {
1014 case SOP_PU_SLEEP:
1015 if (daaint.bitreg.RING) {
1016 if (!j->flags.pstn_ringing) {
1017 if (j->daa_mode != SOP_PU_RINGING) {
1018 j->pstn_ring_int = jiffies;
1019 daa_set_mode(j, SOP_PU_RINGING);
1020 }
1021 }
1022 }
1023 break;
1024 case SOP_PU_RINGING:
1025 if (daaint.bitreg.RMR) {
1026 if (ixjdebug & 0x0008) {
1027 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1028 }
1029 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
1030 j->flags.pstn_rmr = 1;
1031 j->pstn_ring_start = jiffies;
1032 j->pstn_ring_stop = 0;
1033 j->ex.bits.pstn_ring = 0;
1034 if (j->cadence_f[4].state == 0) {
1035 j->cadence_f[4].state = 1;
1036 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
1037 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
1038 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
1039 } else if (j->cadence_f[4].state == 2) {
1040 if((time_after(jiffies, j->cadence_f[4].off1min) &&
1041 time_before(jiffies, j->cadence_f[4].off1max))) {
1042 if (j->cadence_f[4].on2) {
1043 j->cadence_f[4].state = 3;
1044 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 if (ixjdebug & 0x0008) {
1052 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1053 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1054 j->cadence_f[4].off1);
1055 }
1056 j->cadence_f[4].state = 0;
1057 }
1058 } else if (j->cadence_f[4].state == 4) {
1059 if((time_after(jiffies, j->cadence_f[4].off2min) &&
1060 time_before(jiffies, j->cadence_f[4].off2max))) {
1061 if (j->cadence_f[4].on3) {
1062 j->cadence_f[4].state = 5;
1063 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
1064 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
1065 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
1066 } else {
1067 j->cadence_f[4].state = 7;
1068 }
1069 } else {
1070 if (ixjdebug & 0x0008) {
1071 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1072 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1073 j->cadence_f[4].off2);
1074 }
1075 j->cadence_f[4].state = 0;
1076 }
1077 } else if (j->cadence_f[4].state == 6) {
1078 if((time_after(jiffies, j->cadence_f[4].off3min) &&
1079 time_before(jiffies, j->cadence_f[4].off3max))) {
1080 j->cadence_f[4].state = 7;
1081 } else {
1082 if (ixjdebug & 0x0008) {
1083 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1084 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1085 j->cadence_f[4].off3);
1086 }
1087 j->cadence_f[4].state = 0;
1088 }
1089 } else {
1090 j->cadence_f[4].state = 0;
1091 }
1092 } else { /* Falling edge of RMR */
1093 j->pstn_ring_start = 0;
1094 j->pstn_ring_stop = jiffies;
1095 if (j->cadence_f[4].state == 1) {
1096 if(!j->cadence_f[4].on1) {
1097 j->cadence_f[4].state = 7;
1098 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1099 time_before(jiffies, j->cadence_f[4].on1max))) {
1100 if (j->cadence_f[4].off1) {
1101 j->cadence_f[4].state = 2;
1102 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1103 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1104 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1105 } else {
1106 j->cadence_f[4].state = 7;
1107 }
1108 } else {
1109 if (ixjdebug & 0x0008) {
1110 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1111 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1112 j->cadence_f[4].on1);
1113 }
1114 j->cadence_f[4].state = 0;
1115 }
1116 } else if (j->cadence_f[4].state == 3) {
1117 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1118 time_before(jiffies, j->cadence_f[4].on2max))) {
1119 if (j->cadence_f[4].off2) {
1120 j->cadence_f[4].state = 4;
1121 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1122 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1123 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1124 } else {
1125 j->cadence_f[4].state = 7;
1126 }
1127 } else {
1128 if (ixjdebug & 0x0008) {
1129 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1130 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1131 j->cadence_f[4].on2);
1132 }
1133 j->cadence_f[4].state = 0;
1134 }
1135 } else if (j->cadence_f[4].state == 5) {
1136 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1137 time_before(jiffies, j->cadence_f[4].on3max))) {
1138 if (j->cadence_f[4].off3) {
1139 j->cadence_f[4].state = 6;
1140 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1141 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1142 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1143 } else {
1144 j->cadence_f[4].state = 7;
1145 }
1146 } else {
1147 j->cadence_f[4].state = 0;
1148 }
1149 } else {
1150 if (ixjdebug & 0x0008) {
1151 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1152 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1153 j->cadence_f[4].on3);
1154 }
1155 j->cadence_f[4].state = 0;
1156 }
1157 }
1158 if (ixjdebug & 0x0010) {
1159 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1160 }
1161 if (ixjdebug & 0x0010) {
1162 switch(j->cadence_f[4].state) {
1163 case 1:
1164 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1165 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1166 break;
1167 case 2:
1168 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1169 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1170 break;
1171 case 3:
1172 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1173 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1174 break;
1175 case 4:
1176 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1177 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1178 break;
1179 case 5:
1180 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1181 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1182 break;
1183 case 6:
1184 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1185 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1186 break;
1187 }
1188 }
1189 }
1190 if (j->cadence_f[4].state == 7) {
1191 j->cadence_f[4].state = 0;
1192 j->pstn_ring_stop = jiffies;
1193 j->ex.bits.pstn_ring = 1;
1194 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1195 if(ixjdebug & 0x0008) {
1196 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1197 }
1198 }
1199 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1200 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1201 if(ixjdebug & 0x0008) {
1202 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1203 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1204 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1205 }
1206 j->pstn_ring_stop = j->pstn_ring_int = 0;
1207 daa_set_mode(j, SOP_PU_SLEEP);
1208 }
1209 outb_p(j->pld_scrw.byte, j->XILINXbase);
1210 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1211 ixj_daa_cid_read(j);
1212 j->ex.bits.caller_id = 1;
1213 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1214 j->pstn_cid_intr = 0;
1215 }
1216 if (daaint.bitreg.Cadence) {
1217 if(ixjdebug & 0x0008) {
1218 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1219 }
1220 daa_set_mode(j, SOP_PU_SLEEP);
1221 j->ex.bits.pstn_ring = 0;
1222 }
1223 break;
1224 case SOP_PU_CONVERSATION:
1225 if (daaint.bitreg.VDD_OK) {
1226 if(!daaint.bitreg.SI_0) {
1227 if (!j->pstn_winkstart) {
1228 if(ixjdebug & 0x0008) {
1229 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1230 }
1231 j->pstn_winkstart = jiffies;
1232 }
1233 } else {
1234 if (j->pstn_winkstart) {
1235 if(ixjdebug & 0x0008) {
1236 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1237 }
1238 j->pstn_winkstart = 0;
1239 }
1240 }
1241 }
1242 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1243 if(ixjdebug & 0x0008) {
1244 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1245 }
1246 daa_set_mode(j, SOP_PU_SLEEP);
1247 j->pstn_winkstart = 0;
1248 j->ex.bits.pstn_wink = 1;
1249 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1250 }
1251 break;
1252 }
1253 }
1254
1255 static void ixj_timeout(unsigned long ptr)
1256 {
1257 int board;
1258 unsigned long jifon;
1259 IXJ *j = (IXJ *)ptr;
1260 board = j->board;
1261
1262 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1263 ixj_perfmon(j->timerchecks);
1264 j->hookstate = ixj_hookstate(j);
1265 if (j->tone_state) {
1266 if (!(j->hookstate)) {
1267 ixj_cpt_stop(j);
1268 if (j->m_hook) {
1269 j->m_hook = 0;
1270 j->ex.bits.hookstate = 1;
1271 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1272 }
1273 clear_bit(board, &j->busyflags);
1274 ixj_add_timer(j);
1275 return;
1276 }
1277 if (j->tone_state == 1)
1278 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1279 else
1280 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1281 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1282 if (j->tone_state == 1) {
1283 ixj_play_tone(j, j->tone_index);
1284 if (j->dsp.low == 0x20) {
1285 clear_bit(board, &j->busyflags);
1286 ixj_add_timer(j);
1287 return;
1288 }
1289 } else {
1290 ixj_play_tone(j, 0);
1291 if (j->dsp.low == 0x20) {
1292 clear_bit(board, &j->busyflags);
1293 ixj_add_timer(j);
1294 return;
1295 }
1296 }
1297 } else {
1298 ixj_tone_timeout(j);
1299 if (j->flags.dialtone) {
1300 ixj_dialtone(j);
1301 }
1302 if (j->flags.busytone) {
1303 ixj_busytone(j);
1304 if (j->dsp.low == 0x20) {
1305 clear_bit(board, &j->busyflags);
1306 ixj_add_timer(j);
1307 return;
1308 }
1309 }
1310 if (j->flags.ringback) {
1311 ixj_ringback(j);
1312 if (j->dsp.low == 0x20) {
1313 clear_bit(board, &j->busyflags);
1314 ixj_add_timer(j);
1315 return;
1316 }
1317 }
1318 if (!j->tone_state) {
1319 ixj_cpt_stop(j);
1320 }
1321 }
1322 }
1323 if (!(j->tone_state && j->dsp.low == 0x20)) {
1324 if (IsRxReady(j)) {
1325 ixj_read_frame(j);
1326 }
1327 if (IsTxReady(j)) {
1328 ixj_write_frame(j);
1329 }
1330 }
1331 if (j->flags.cringing) {
1332 if (j->hookstate & 1) {
1333 j->flags.cringing = 0;
1334 ixj_ring_off(j);
1335 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1336 switch(j->cadence_f[5].state) {
1337 case 0:
1338 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1339 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1340 if(ixjdebug & 0x0004) {
1341 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1342 }
1343 ixj_ring_on(j);
1344 }
1345 j->cadence_f[5].state = 1;
1346 break;
1347 case 1:
1348 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1349 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1350 if(ixjdebug & 0x0004) {
1351 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1352 }
1353 ixj_ring_off(j);
1354 j->cadence_f[5].state = 2;
1355 }
1356 break;
1357 case 2:
1358 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1359 if(ixjdebug & 0x0004) {
1360 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1361 }
1362 ixj_ring_on(j);
1363 if (j->cadence_f[5].on2) {
1364 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1365 j->cadence_f[5].state = 3;
1366 } else {
1367 j->cadence_f[5].state = 7;
1368 }
1369 }
1370 break;
1371 case 3:
1372 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1373 if(ixjdebug & 0x0004) {
1374 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1375 }
1376 ixj_ring_off(j);
1377 if (j->cadence_f[5].off2) {
1378 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1379 j->cadence_f[5].state = 4;
1380 } else {
1381 j->cadence_f[5].state = 7;
1382 }
1383 }
1384 break;
1385 case 4:
1386 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1387 if(ixjdebug & 0x0004) {
1388 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1389 }
1390 ixj_ring_on(j);
1391 if (j->cadence_f[5].on3) {
1392 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1393 j->cadence_f[5].state = 5;
1394 } else {
1395 j->cadence_f[5].state = 7;
1396 }
1397 }
1398 break;
1399 case 5:
1400 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1401 if(ixjdebug & 0x0004) {
1402 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1403 }
1404 ixj_ring_off(j);
1405 if (j->cadence_f[5].off3) {
1406 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1407 j->cadence_f[5].state = 6;
1408 } else {
1409 j->cadence_f[5].state = 7;
1410 }
1411 }
1412 break;
1413 case 6:
1414 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1415 if(ixjdebug & 0x0004) {
1416 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1417 }
1418 j->cadence_f[5].state = 7;
1419 }
1420 break;
1421 case 7:
1422 if(ixjdebug & 0x0004) {
1423 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1424 }
1425 j->flags.cidring = 1;
1426 j->cadence_f[5].state = 0;
1427 break;
1428 }
1429 if (j->flags.cidring && !j->flags.cidsent) {
1430 j->flags.cidsent = 1;
1431 if(j->fskdcnt) {
1432 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1433 ixj_pre_cid(j);
1434 }
1435 j->flags.cidring = 0;
1436 }
1437 clear_bit(board, &j->busyflags);
1438 ixj_add_timer(j);
1439 return;
1440 } else {
1441 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1442 if (j->flags.cidring && !j->flags.cidsent) {
1443 j->flags.cidsent = 1;
1444 if(j->fskdcnt) {
1445 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1446 ixj_pre_cid(j);
1447 }
1448 j->flags.cidring = 0;
1449 }
1450 j->ring_cadence_t--;
1451 if (j->ring_cadence_t == -1)
1452 j->ring_cadence_t = 15;
1453 j->ring_cadence_jif = jiffies;
1454
1455 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1456 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1457 j->flags.firstring = 1;
1458 else
1459 ixj_ring_on(j);
1460 } else {
1461 ixj_ring_off(j);
1462 if(!j->flags.cidsent)
1463 j->flags.cidring = 1;
1464 }
1465 }
1466 clear_bit(board, &j->busyflags);
1467 ixj_add_timer(j);
1468 return;
1469 }
1470 }
1471 if (!j->flags.ringing) {
1472 if (j->hookstate) { /* & 1) { */
1473 if (j->dsp.low != 0x20 &&
1474 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1475 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1476 }
1477 LineMonitor(j);
1478 read_filters(j);
1479 ixj_WriteDSPCommand(0x511B, j);
1480 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1481 if (!j->m_hook && (j->hookstate & 1)) {
1482 j->m_hook = j->ex.bits.hookstate = 1;
1483 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1484 }
1485 } else {
1486 if (j->ex.bits.dtmf_ready) {
1487 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1488 }
1489 if (j->m_hook) {
1490 j->m_hook = 0;
1491 j->ex.bits.hookstate = 1;
1492 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1493 }
1494 }
1495 }
1496 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1497 ixj_pstn_state(j);
1498 }
1499 if (j->ex.bytes) {
1500 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1501 }
1502 clear_bit(board, &j->busyflags);
1503 }
1504 ixj_add_timer(j);
1505 }
1506
1507 static int ixj_status_wait(IXJ *j)
1508 {
1509 unsigned long jif;
1510
1511 jif = jiffies + ((60 * hertz) / 100);
1512 while (!IsStatusReady(j)) {
1513 ixj_perfmon(j->statuswait);
1514 if (time_after(jiffies, jif)) {
1515 ixj_perfmon(j->statuswaitfail);
1516 return -1;
1517 }
1518 }
1519 return 0;
1520 }
1521
1522 static int ixj_PCcontrol_wait(IXJ *j)
1523 {
1524 unsigned long jif;
1525
1526 jif = jiffies + ((60 * hertz) / 100);
1527 while (!IsPCControlReady(j)) {
1528 ixj_perfmon(j->pcontrolwait);
1529 if (time_after(jiffies, jif)) {
1530 ixj_perfmon(j->pcontrolwaitfail);
1531 return -1;
1532 }
1533 }
1534 return 0;
1535 }
1536
1537 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1538 {
1539 BYTES bytes;
1540 unsigned long jif;
1541
1542 atomic_inc(&j->DSPWrite);
1543 if(atomic_read(&j->DSPWrite) > 1) {
1544 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1545 return -1;
1546 }
1547 bytes.high = (cmd & 0xFF00) >> 8;
1548 bytes.low = cmd & 0x00FF;
1549 jif = jiffies + ((60 * hertz) / 100);
1550 while (!IsControlReady(j)) {
1551 ixj_perfmon(j->iscontrolready);
1552 if (time_after(jiffies, jif)) {
1553 ixj_perfmon(j->iscontrolreadyfail);
1554 atomic_dec(&j->DSPWrite);
1555 if(atomic_read(&j->DSPWrite) > 0) {
1556 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1557 while(atomic_read(&j->DSPWrite) > 0) {
1558 atomic_dec(&j->DSPWrite);
1559 }
1560 }
1561 return -1;
1562 }
1563 }
1564 outb(bytes.low, j->DSPbase + 6);
1565 outb(bytes.high, j->DSPbase + 7);
1566
1567 if (ixj_status_wait(j)) {
1568 j->ssr.low = 0xFF;
1569 j->ssr.high = 0xFF;
1570 atomic_dec(&j->DSPWrite);
1571 if(atomic_read(&j->DSPWrite) > 0) {
1572 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1573 while(atomic_read(&j->DSPWrite) > 0) {
1574 atomic_dec(&j->DSPWrite);
1575 }
1576 }
1577 return -1;
1578 }
1579 /* Read Software Status Register */
1580 j->ssr.low = inb_p(j->DSPbase + 2);
1581 j->ssr.high = inb_p(j->DSPbase + 3);
1582 atomic_dec(&j->DSPWrite);
1583 if(atomic_read(&j->DSPWrite) > 0) {
1584 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1585 while(atomic_read(&j->DSPWrite) > 0) {
1586 atomic_dec(&j->DSPWrite);
1587 }
1588 }
1589 return 0;
1590 }
1591
1592 /***************************************************************************
1593 *
1594 * General Purpose IO Register read routine
1595 *
1596 ***************************************************************************/
1597 static inline int ixj_gpio_read(IXJ *j)
1598 {
1599 if (ixj_WriteDSPCommand(0x5143, j))
1600 return -1;
1601
1602 j->gpio.bytes.low = j->ssr.low;
1603 j->gpio.bytes.high = j->ssr.high;
1604
1605 return 0;
1606 }
1607
1608 static inline void LED_SetState(int state, IXJ *j)
1609 {
1610 if (j->cardtype == QTI_LINEJACK) {
1611 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1612 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1613 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1614 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1615
1616 outb(j->pld_scrw.byte, j->XILINXbase);
1617 }
1618 }
1619
1620 /*********************************************************************
1621 * GPIO Pins are configured as follows on the Quicknet Internet
1622 * PhoneJACK Telephony Cards
1623 *
1624 * POTS Select GPIO_6=0 GPIO_7=0
1625 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1626 * Handset Select GPIO_6=1 GPIO_7=0
1627 *
1628 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1629 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1630 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1631 *
1632 * Hook Switch changes reported on GPIO_3
1633 *********************************************************************/
1634 static int ixj_set_port(IXJ *j, int arg)
1635 {
1636 if (j->cardtype == QTI_PHONEJACK_LITE) {
1637 if (arg != PORT_POTS)
1638 return 10;
1639 else
1640 return 0;
1641 }
1642 switch (arg) {
1643 case PORT_POTS:
1644 j->port = PORT_POTS;
1645 switch (j->cardtype) {
1646 case QTI_PHONECARD:
1647 if (j->flags.pcmciasct == 1)
1648 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1649 else
1650 return 11;
1651 break;
1652 case QTI_PHONEJACK_PCI:
1653 j->pld_slicw.pcib.mic = 0;
1654 j->pld_slicw.pcib.spk = 0;
1655 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1656 break;
1657 case QTI_LINEJACK:
1658 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1659 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1660 Software Control Register */
1661 return 2;
1662 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1663
1664 outb(j->pld_scrw.byte, j->XILINXbase);
1665 j->pld_clock.byte = 0;
1666 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1667 j->pld_slicw.bits.rly1 = 1;
1668 j->pld_slicw.bits.spken = 0;
1669 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1670 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1671 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1672 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1673 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1674 ixj_mixer(0x0E80, j); /*Mic mute */
1675 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1676 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1677 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1678 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1679 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1680 break;
1681 case QTI_PHONEJACK:
1682 j->gpio.bytes.high = 0x0B;
1683 j->gpio.bits.gpio6 = 0;
1684 j->gpio.bits.gpio7 = 0;
1685 ixj_WriteDSPCommand(j->gpio.word, j);
1686 break;
1687 }
1688 break;
1689 case PORT_PSTN:
1690 if (j->cardtype == QTI_LINEJACK) {
1691 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1692
1693 j->pld_slicw.bits.rly3 = 0;
1694 j->pld_slicw.bits.rly1 = 1;
1695 j->pld_slicw.bits.spken = 0;
1696 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1697 j->port = PORT_PSTN;
1698 } else {
1699 return 4;
1700 }
1701 break;
1702 case PORT_SPEAKER:
1703 j->port = PORT_SPEAKER;
1704 switch (j->cardtype) {
1705 case QTI_PHONECARD:
1706 if (j->flags.pcmciasct) {
1707 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1708 }
1709 break;
1710 case QTI_PHONEJACK_PCI:
1711 j->pld_slicw.pcib.mic = 1;
1712 j->pld_slicw.pcib.spk = 1;
1713 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1714 break;
1715 case QTI_LINEJACK:
1716 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1717 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1718 Software Control Register */
1719 return 2;
1720 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1721
1722 outb(j->pld_scrw.byte, j->XILINXbase);
1723 j->pld_clock.byte = 0;
1724 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1725 j->pld_slicw.bits.rly1 = 1;
1726 j->pld_slicw.bits.spken = 1;
1727 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1728 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1729 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1730 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1731 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1732 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1733 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1734 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1735 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1736 break;
1737 case QTI_PHONEJACK:
1738 j->gpio.bytes.high = 0x0B;
1739 j->gpio.bits.gpio6 = 0;
1740 j->gpio.bits.gpio7 = 1;
1741 ixj_WriteDSPCommand(j->gpio.word, j);
1742 break;
1743 }
1744 break;
1745 case PORT_HANDSET:
1746 if (j->cardtype != QTI_PHONEJACK) {
1747 return 5;
1748 } else {
1749 j->gpio.bytes.high = 0x0B;
1750 j->gpio.bits.gpio6 = 1;
1751 j->gpio.bits.gpio7 = 0;
1752 ixj_WriteDSPCommand(j->gpio.word, j);
1753 j->port = PORT_HANDSET;
1754 }
1755 break;
1756 default:
1757 return 6;
1758 break;
1759 }
1760 return 0;
1761 }
1762
1763 static int ixj_set_pots(IXJ *j, int arg)
1764 {
1765 if (j->cardtype == QTI_LINEJACK) {
1766 if (arg) {
1767 if (j->port == PORT_PSTN) {
1768 j->pld_slicw.bits.rly1 = 0;
1769 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1770 j->flags.pots_pstn = 1;
1771 return 1;
1772 } else {
1773 j->flags.pots_pstn = 0;
1774 return 0;
1775 }
1776 } else {
1777 j->pld_slicw.bits.rly1 = 1;
1778 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1779 j->flags.pots_pstn = 0;
1780 return 1;
1781 }
1782 } else {
1783 return 0;
1784 }
1785 }
1786
1787 static void ixj_ring_on(IXJ *j)
1788 {
1789 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1790 {
1791 if (ixjdebug & 0x0004)
1792 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1793
1794 j->gpio.bytes.high = 0x0B;
1795 j->gpio.bytes.low = 0x00;
1796 j->gpio.bits.gpio1 = 1;
1797 j->gpio.bits.gpio2 = 1;
1798 j->gpio.bits.gpio5 = 0;
1799 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1800 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1801 {
1802 if (ixjdebug & 0x0004)
1803 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1804
1805 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1806 }
1807 }
1808
1809 static int ixj_siadc(IXJ *j, int val)
1810 {
1811 if(j->cardtype == QTI_PHONECARD){
1812 if(j->flags.pcmciascp){
1813 if(val == -1)
1814 return j->siadc.bits.rxg;
1815
1816 if(val < 0 || val > 0x1F)
1817 return -1;
1818
1819 j->siadc.bits.hom = 0; /* Handset Out Mute */
1820 j->siadc.bits.lom = 0; /* Line Out Mute */
1821 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1822 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1823 j->psccr.bits.rw = 0; /* Read / Write flag */
1824 j->psccr.bits.dev = 0;
1825 outb(j->siadc.byte, j->XILINXbase + 0x00);
1826 outb(j->psccr.byte, j->XILINXbase + 0x01);
1827 ixj_PCcontrol_wait(j);
1828 return j->siadc.bits.rxg;
1829 }
1830 }
1831 return -1;
1832 }
1833
1834 static int ixj_sidac(IXJ *j, int val)
1835 {
1836 if(j->cardtype == QTI_PHONECARD){
1837 if(j->flags.pcmciascp){
1838 if(val == -1)
1839 return j->sidac.bits.txg;
1840
1841 if(val < 0 || val > 0x1F)
1842 return -1;
1843
1844 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1845 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1846 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1847 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1848 j->psccr.bits.rw = 0; /* Read / Write flag */
1849 j->psccr.bits.dev = 0;
1850 outb(j->sidac.byte, j->XILINXbase + 0x00);
1851 outb(j->psccr.byte, j->XILINXbase + 0x01);
1852 ixj_PCcontrol_wait(j);
1853 return j->sidac.bits.txg;
1854 }
1855 }
1856 return -1;
1857 }
1858
1859 static int ixj_pcmcia_cable_check(IXJ *j)
1860 {
1861 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1862 if (!j->flags.pcmciastate) {
1863 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1864 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1865 j->flags.pcmciastate = 4;
1866 return 0;
1867 }
1868 if (j->pccr1.bits.ed) {
1869 j->pccr1.bits.ed = 0;
1870 j->psccr.bits.dev = 3;
1871 j->psccr.bits.rw = 1;
1872 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1873 ixj_PCcontrol_wait(j);
1874 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1875 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1876 j->psccr.bits.dev = 3;
1877 j->psccr.bits.rw = 0;
1878 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1879 ixj_PCcontrol_wait(j);
1880 return j->pslic.bits.led2 ? 1 : 0;
1881 } else if (j->flags.pcmciasct) {
1882 return j->r_hook;
1883 } else {
1884 return 1;
1885 }
1886 } else if (j->flags.pcmciastate == 4) {
1887 if (!j->pccr1.bits.drf) {
1888 j->flags.pcmciastate = 3;
1889 }
1890 return 0;
1891 } else if (j->flags.pcmciastate == 3) {
1892 j->pccr2.bits.pwr = 0;
1893 j->pccr2.bits.rstc = 1;
1894 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1895 j->checkwait = jiffies + (hertz * 2);
1896 j->flags.incheck = 1;
1897 j->flags.pcmciastate = 2;
1898 return 0;
1899 } else if (j->flags.pcmciastate == 2) {
1900 if (j->flags.incheck) {
1901 if (time_before(jiffies, j->checkwait)) {
1902 return 0;
1903 } else {
1904 j->flags.incheck = 0;
1905 }
1906 }
1907 j->pccr2.bits.pwr = 0;
1908 j->pccr2.bits.rstc = 0;
1909 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1910 j->flags.pcmciastate = 1;
1911 return 0;
1912 } else if (j->flags.pcmciastate == 1) {
1913 j->flags.pcmciastate = 0;
1914 if (!j->pccr1.bits.drf) {
1915 j->psccr.bits.dev = 3;
1916 j->psccr.bits.rw = 1;
1917 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1918 ixj_PCcontrol_wait(j);
1919 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1920
1921 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1922
1923 if (j->flags.pcmciasct == 3) {
1924 j->flags.pcmciastate = 4;
1925 return 0;
1926 } else if (j->flags.pcmciasct == 0) {
1927 j->pccr2.bits.pwr = 1;
1928 j->pccr2.bits.rstc = 0;
1929 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1930 j->port = PORT_SPEAKER;
1931 } else {
1932 j->port = PORT_POTS;
1933 }
1934 j->sic1.bits.cpd = 0; /* Chip Power Down */
1935 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1936 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1937 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1938 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1939 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1940 j->psccr.bits.rw = 0; /* Read / Write flag */
1941 j->psccr.bits.dev = 0;
1942 outb(j->sic1.byte, j->XILINXbase + 0x00);
1943 outb(j->psccr.byte, j->XILINXbase + 0x01);
1944 ixj_PCcontrol_wait(j);
1945
1946 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1947 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1948 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1949 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1950 j->sic2.bits.hpd = 0; /* HPF disable */
1951 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1952 j->psccr.bits.rw = 0; /* Read / Write flag */
1953 j->psccr.bits.dev = 0;
1954 outb(j->sic2.byte, j->XILINXbase + 0x00);
1955 outb(j->psccr.byte, j->XILINXbase + 0x01);
1956 ixj_PCcontrol_wait(j);
1957
1958 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1959 j->psccr.bits.rw = 0; /* Read / Write flag */
1960 j->psccr.bits.dev = 0;
1961 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1962 outb(j->psccr.byte, j->XILINXbase + 0x01);
1963 ixj_PCcontrol_wait(j);
1964
1965 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1966 j->psccr.bits.rw = 0; /* Read / Write flag */
1967 j->psccr.bits.dev = 0;
1968 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1969 outb(j->psccr.byte, j->XILINXbase + 0x01);
1970 ixj_PCcontrol_wait(j);
1971
1972 j->sirxg.bits.lig = 1; /* Line In Gain */
1973 j->sirxg.bits.lim = 1; /* Line In Mute */
1974 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1975 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1976 j->sirxg.bits.him = 0; /* Handset In Mute */
1977 j->sirxg.bits.iir = 1; /* IIR */
1978 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1979 j->psccr.bits.rw = 0; /* Read / Write flag */
1980 j->psccr.bits.dev = 0;
1981 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1982 outb(j->psccr.byte, j->XILINXbase + 0x01);
1983 ixj_PCcontrol_wait(j);
1984
1985 ixj_siadc(j, 0x17);
1986 ixj_sidac(j, 0x1D);
1987
1988 j->siaatt.bits.sot = 0;
1989 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1990 j->psccr.bits.rw = 0; /* Read / Write flag */
1991 j->psccr.bits.dev = 0;
1992 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1993 outb(j->psccr.byte, j->XILINXbase + 0x01);
1994 ixj_PCcontrol_wait(j);
1995
1996 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1997 j->psccr.byte = j->pslic.byte = 0;
1998 j->pslic.bits.powerdown = 1;
1999 j->psccr.bits.dev = 3;
2000 j->psccr.bits.rw = 0;
2001 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2002 ixj_PCcontrol_wait(j);
2003 }
2004 }
2005 return 0;
2006 } else {
2007 j->flags.pcmciascp = 0;
2008 return 0;
2009 }
2010 return 0;
2011 }
2012
2013 static int ixj_hookstate(IXJ *j)
2014 {
2015 unsigned long det;
2016 int fOffHook = 0;
2017
2018 switch (j->cardtype) {
2019 case QTI_PHONEJACK:
2020 ixj_gpio_read(j);
2021 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
2022 break;
2023 case QTI_LINEJACK:
2024 case QTI_PHONEJACK_LITE:
2025 case QTI_PHONEJACK_PCI:
2026 SLIC_GetState(j);
2027 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
2028 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
2029 if(fOffHook != j->p_hook) {
2030 if(!j->checkwait) {
2031 j->checkwait = jiffies;
2032 }
2033 if(time_before(jiffies, j->checkwait + 2)) {
2034 fOffHook ^= 1;
2035 } else {
2036 j->checkwait = 0;
2037 }
2038 j->p_hook = fOffHook;
2039 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
2040 }
2041 } else {
2042 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
2043 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
2044 if (j->flags.ringing || j->flags.cringing) {
2045 if (!in_interrupt()) {
2046 det = jiffies + (hertz / 50);
2047 while (time_before(jiffies, det)) {
2048 set_current_state(TASK_INTERRUPTIBLE);
2049 schedule_timeout(1);
2050 }
2051 }
2052 SLIC_GetState(j);
2053 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
2054 ixj_ring_on(j);
2055 }
2056 }
2057 if (j->cardtype == QTI_PHONEJACK_PCI) {
2058 j->pld_scrr.byte = inb_p(j->XILINXbase);
2059 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
2060 } else
2061 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
2062 }
2063 }
2064 break;
2065 case QTI_PHONECARD:
2066 fOffHook = ixj_pcmcia_cable_check(j);
2067 break;
2068 }
2069 if (j->r_hook != fOffHook) {
2070 j->r_hook = fOffHook;
2071 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
2072 j->ex.bits.hookstate = 1;
2073 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
2074 } else if (!fOffHook) {
2075 j->flash_end = jiffies + ((60 * hertz) / 100);
2076 }
2077 }
2078 if (fOffHook) {
2079 if(time_before(jiffies, j->flash_end)) {
2080 j->ex.bits.flash = 1;
2081 j->flash_end = 0;
2082 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
2083 }
2084 } else {
2085 if(time_before(jiffies, j->flash_end)) {
2086 fOffHook = 1;
2087 }
2088 }
2089
2090 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
2091 fOffHook |= 2;
2092
2093 if (j->port == PORT_SPEAKER) {
2094 if(j->cardtype == QTI_PHONECARD) {
2095 if(j->flags.pcmciascp && j->flags.pcmciasct) {
2096 fOffHook |= 2;
2097 }
2098 } else {
2099 fOffHook |= 2;
2100 }
2101 }
2102
2103 if (j->port == PORT_HANDSET)
2104 fOffHook |= 2;
2105
2106 return fOffHook;
2107 }
2108
2109 static void ixj_ring_off(IXJ *j)
2110 {
2111 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2112 {
2113 if (ixjdebug & 0x0004)
2114 printk(KERN_INFO "IXJ Ring Off\n");
2115 j->gpio.bytes.high = 0x0B;
2116 j->gpio.bytes.low = 0x00;
2117 j->gpio.bits.gpio1 = 0;
2118 j->gpio.bits.gpio2 = 1;
2119 j->gpio.bits.gpio5 = 0;
2120 ixj_WriteDSPCommand(j->gpio.word, j);
2121 } else /* Internet LineJACK */
2122 {
2123 if (ixjdebug & 0x0004)
2124 printk(KERN_INFO "IXJ Ring Off\n");
2125
2126 if(!j->flags.cidplay)
2127 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2128
2129 SLIC_GetState(j);
2130 }
2131 }
2132
2133 static void ixj_ring_start(IXJ *j)
2134 {
2135 j->flags.cringing = 1;
2136 if (ixjdebug & 0x0004)
2137 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2138 if (ixj_hookstate(j) & 1) {
2139 if (j->port == PORT_POTS)
2140 ixj_ring_off(j);
2141 j->flags.cringing = 0;
2142 if (ixjdebug & 0x0004)
2143 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2144 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2145 j->ring_cadence_jif = jiffies;
2146 j->flags.cidsent = j->flags.cidring = 0;
2147 j->cadence_f[5].state = 0;
2148 if(j->cadence_f[5].on1)
2149 ixj_ring_on(j);
2150 } else {
2151 j->ring_cadence_jif = jiffies;
2152 j->ring_cadence_t = 15;
2153 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2154 ixj_ring_on(j);
2155 } else {
2156 ixj_ring_off(j);
2157 }
2158 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2159 }
2160 }
2161
2162 static int ixj_ring(IXJ *j)
2163 {
2164 char cntr;
2165 unsigned long jif, det;
2166
2167 j->flags.ringing = 1;
2168 if (ixj_hookstate(j) & 1) {
2169 ixj_ring_off(j);
2170 j->flags.ringing = 0;
2171 return 1;
2172 }
2173 det = 0;
2174 for (cntr = 0; cntr < j->maxrings; cntr++) {
2175 jif = jiffies + (1 * hertz);
2176 ixj_ring_on(j);
2177 while (time_before(jiffies, jif)) {
2178 if (ixj_hookstate(j) & 1) {
2179 ixj_ring_off(j);
2180 j->flags.ringing = 0;
2181 return 1;
2182 }
2183 set_current_state(TASK_INTERRUPTIBLE);
2184 schedule_timeout(1);
2185 if (signal_pending(current))
2186 break;
2187 }
2188 jif = jiffies + (3 * hertz);
2189 ixj_ring_off(j);
2190 while (time_before(jiffies, jif)) {
2191 if (ixj_hookstate(j) & 1) {
2192 det = jiffies + (hertz / 100);
2193 while (time_before(jiffies, det)) {
2194 set_current_state(TASK_INTERRUPTIBLE);
2195 schedule_timeout(1);
2196 if (signal_pending(current))
2197 break;
2198 }
2199 if (ixj_hookstate(j) & 1) {
2200 j->flags.ringing = 0;
2201 return 1;
2202 }
2203 }
2204 set_current_state(TASK_INTERRUPTIBLE);
2205 schedule_timeout(1);
2206 if (signal_pending(current))
2207 break;
2208 }
2209 }
2210 ixj_ring_off(j);
2211 j->flags.ringing = 0;
2212 return 0;
2213 }
2214
2215 static int ixj_open(struct phone_device *p, struct file *file_p)
2216 {
2217 IXJ *j = get_ixj(p->board);
2218 file_p->private_data = j;
2219
2220 if (!j->DSPbase)
2221 return -ENODEV;
2222
2223 if (file_p->f_mode & FMODE_READ) {
2224 if(!j->readers) {
2225 j->readers++;
2226 } else {
2227 return -EBUSY;
2228 }
2229 }
2230
2231 if (file_p->f_mode & FMODE_WRITE) {
2232 if(!j->writers) {
2233 j->writers++;
2234 } else {
2235 if (file_p->f_mode & FMODE_READ){
2236 j->readers--;
2237 }
2238 return -EBUSY;
2239 }
2240 }
2241
2242 if (j->cardtype == QTI_PHONECARD) {
2243 j->pslic.bits.powerdown = 0;
2244 j->psccr.bits.dev = 3;
2245 j->psccr.bits.rw = 0;
2246 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2247 ixj_PCcontrol_wait(j);
2248 }
2249
2250 j->flags.cidplay = 0;
2251 j->flags.cidcw_ack = 0;
2252
2253 MOD_INC_USE_COUNT;
2254
2255 if (ixjdebug & 0x0002)
2256 printk(KERN_INFO "Opening board %d\n", p->board);
2257
2258 j->framesread = j->frameswritten = 0;
2259 return 0;
2260 }
2261
2262 int ixj_release(struct inode *inode, struct file *file_p)
2263 {
2264 IXJ_TONE ti;
2265 int cnt;
2266 IXJ *j = file_p->private_data;
2267 int board = j->p.board;
2268
2269 /*
2270 * Set up locks to ensure that only one process is talking to the DSP at a time.
2271 * This is necessary to keep the DSP from locking up.
2272 */
2273 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2274 set_current_state(TASK_INTERRUPTIBLE);
2275 schedule_timeout(1);
2276 }
2277 if (ixjdebug & 0x0002)
2278 printk(KERN_INFO "Closing board %d\n", NUM(inode->i_rdev));
2279
2280 if (j->cardtype == QTI_PHONECARD)
2281 ixj_set_port(j, PORT_SPEAKER);
2282 else
2283 ixj_set_port(j, PORT_POTS);
2284
2285 aec_stop(j);
2286 ixj_play_stop(j);
2287 ixj_record_stop(j);
2288 set_play_volume(j, 0x100);
2289 set_rec_volume(j, 0x100);
2290 ixj_ring_off(j);
2291
2292 /* Restore the tone table to default settings. */
2293 ti.tone_index = 10;
2294 ti.gain0 = 1;
2295 ti.freq0 = hz941;
2296 ti.gain1 = 0;
2297 ti.freq1 = hz1209;
2298 ixj_init_tone(j, &ti);
2299 ti.tone_index = 11;
2300 ti.gain0 = 1;
2301 ti.freq0 = hz941;
2302 ti.gain1 = 0;
2303 ti.freq1 = hz1336;
2304 ixj_init_tone(j, &ti);
2305 ti.tone_index = 12;
2306 ti.gain0 = 1;
2307 ti.freq0 = hz941;
2308 ti.gain1 = 0;
2309 ti.freq1 = hz1477;
2310 ixj_init_tone(j, &ti);
2311 ti.tone_index = 13;
2312 ti.gain0 = 1;
2313 ti.freq0 = hz800;
2314 ti.gain1 = 0;
2315 ti.freq1 = 0;
2316 ixj_init_tone(j, &ti);
2317 ti.tone_index = 14;
2318 ti.gain0 = 1;
2319 ti.freq0 = hz1000;
2320 ti.gain1 = 0;
2321 ti.freq1 = 0;
2322 ixj_init_tone(j, &ti);
2323 ti.tone_index = 15;
2324 ti.gain0 = 1;
2325 ti.freq0 = hz1250;
2326 ti.gain1 = 0;
2327 ti.freq1 = 0;
2328 ixj_init_tone(j, &ti);
2329 ti.tone_index = 16;
2330 ti.gain0 = 1;
2331 ti.freq0 = hz950;
2332 ti.gain1 = 0;
2333 ti.freq1 = 0;
2334 ixj_init_tone(j, &ti);
2335 ti.tone_index = 17;
2336 ti.gain0 = 1;
2337 ti.freq0 = hz1100;
2338 ti.gain1 = 0;
2339 ti.freq1 = 0;
2340 ixj_init_tone(j, &ti);
2341 ti.tone_index = 18;
2342 ti.gain0 = 1;
2343 ti.freq0 = hz1400;
2344 ti.gain1 = 0;
2345 ti.freq1 = 0;
2346 ixj_init_tone(j, &ti);
2347 ti.tone_index = 19;
2348 ti.gain0 = 1;
2349 ti.freq0 = hz1500;
2350 ti.gain1 = 0;
2351 ti.freq1 = 0;
2352 ixj_init_tone(j, &ti);
2353 ti.tone_index = 20;
2354 ti.gain0 = 1;
2355 ti.freq0 = hz1600;
2356 ti.gain1 = 0;
2357 ti.freq1 = 0;
2358 ixj_init_tone(j, &ti);
2359 ti.tone_index = 21;
2360 ti.gain0 = 1;
2361 ti.freq0 = hz1800;
2362 ti.gain1 = 0;
2363 ti.freq1 = 0;
2364 ixj_init_tone(j, &ti);
2365 ti.tone_index = 22;
2366 ti.gain0 = 1;
2367 ti.freq0 = hz2100;
2368 ti.gain1 = 0;
2369 ti.freq1 = 0;
2370 ixj_init_tone(j, &ti);
2371 ti.tone_index = 23;
2372 ti.gain0 = 1;
2373 ti.freq0 = hz1300;
2374 ti.gain1 = 0;
2375 ti.freq1 = 0;
2376 ixj_init_tone(j, &ti);
2377 ti.tone_index = 24;
2378 ti.gain0 = 1;
2379 ti.freq0 = hz2450;
2380 ti.gain1 = 0;
2381 ti.freq1 = 0;
2382 ixj_init_tone(j, &ti);
2383 ti.tone_index = 25;
2384 ti.gain0 = 1;
2385 ti.freq0 = hz350;
2386 ti.gain1 = 0;
2387 ti.freq1 = hz440;
2388 ixj_init_tone(j, &ti);
2389 ti.tone_index = 26;
2390 ti.gain0 = 1;
2391 ti.freq0 = hz440;
2392 ti.gain1 = 0;
2393 ti.freq1 = hz480;
2394 ixj_init_tone(j, &ti);
2395 ti.tone_index = 27;
2396 ti.gain0 = 1;
2397 ti.freq0 = hz480;
2398 ti.gain1 = 0;
2399 ti.freq1 = hz620;
2400 ixj_init_tone(j, &ti);
2401
2402 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2403
2404 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2405
2406 j->ex.bits.dtmf_ready = 0;
2407 j->dtmf_state = 0;
2408 j->dtmf_wp = j->dtmf_rp = 0;
2409 j->rec_mode = j->play_mode = -1;
2410 j->flags.ringing = 0;
2411 j->maxrings = MAXRINGS;
2412 j->ring_cadence = USA_RING_CADENCE;
2413 if(j->cadence_f[5].enable) {
2414 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2415 }
2416 j->drybuffer = 0;
2417 j->winktime = 320;
2418 j->flags.dtmf_oob = 0;
2419 for (cnt = 0; cnt < 4; cnt++)
2420 j->cadence_f[cnt].enable = 0;
2421
2422 idle(j);
2423
2424 if(j->cardtype == QTI_PHONECARD) {
2425 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2426 }
2427
2428 if (file_p->f_mode & FMODE_READ)
2429 j->readers--;
2430 if (file_p->f_mode & FMODE_WRITE)
2431 j->writers--;
2432
2433 if (j->read_buffer && !j->readers) {
2434 kfree(j->read_buffer);
2435 j->read_buffer = NULL;
2436 j->read_buffer_size = 0;
2437 }
2438 if (j->write_buffer && !j->writers) {
2439 kfree(j->write_buffer);
2440 j->write_buffer = NULL;
2441 j->write_buffer_size = 0;
2442 }
2443 j->rec_codec = j->play_codec = 0;
2444 j->rec_frame_size = j->play_frame_size = 0;
2445 j->flags.cidsent = j->flags.cidring = 0;
2446 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2447
2448 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2449 ixj_set_port(j, PORT_PSTN);
2450 daa_set_mode(j, SOP_PU_SLEEP);
2451 ixj_set_pots(j, 1);
2452 }
2453 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2454
2455 /* Set up the default signals for events */
2456 for (cnt = 0; cnt < 35; cnt++)
2457 j->ixj_signals[cnt] = SIGIO;
2458
2459 /* Set the excetion signal enable flags */
2460 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2461 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 =
2462 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;
2463
2464 file_p->private_data = NULL;
2465 clear_bit(board, &j->busyflags);
2466 MOD_DEC_USE_COUNT;
2467 return 0;
2468 }
2469
2470 static int read_filters(IXJ *j)
2471 {
2472 unsigned short fc, cnt, trg;
2473 int var;
2474
2475 trg = 0;
2476 if (ixj_WriteDSPCommand(0x5144, j)) {
2477 if(ixjdebug & 0x0001) {
2478 printk(KERN_INFO "Read Frame Counter failed!\n");
2479 }
2480 return -1;
2481 }
2482 fc = j->ssr.high << 8 | j->ssr.low;
2483 if (fc == j->frame_count)
2484 return 1;
2485
2486 j->frame_count = fc;
2487
2488 if (j->dtmf_proc)
2489 return 1;
2490
2491 var = 10;
2492
2493 for (cnt = 0; cnt < 4; cnt++) {
2494 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2495 if(ixjdebug & 0x0001) {
2496 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2497 }
2498 return -1;
2499 }
2500 if (ixj_WriteDSPCommand(0x515C, j)) {
2501 if(ixjdebug & 0x0001) {
2502 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2503 }
2504 return -1;
2505 }
2506 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2507
2508 if (j->cadence_f[cnt].enable) {
2509 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2510 if (j->cadence_f[cnt].state == 0) {
2511 j->cadence_f[cnt].state = 1;
2512 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2513 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2514 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2515 } else if (j->cadence_f[cnt].state == 2 &&
2516 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2517 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2518 if (j->cadence_f[cnt].on2) {
2519 j->cadence_f[cnt].state = 3;
2520 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2521 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2522 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2523 } else {
2524 j->cadence_f[cnt].state = 7;
2525 }
2526 } else if (j->cadence_f[cnt].state == 4 &&
2527 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2528 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2529 if (j->cadence_f[cnt].on3) {
2530 j->cadence_f[cnt].state = 5;
2531 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2532 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2533 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2534 } else {
2535 j->cadence_f[cnt].state = 7;
2536 }
2537 } else {
2538 j->cadence_f[cnt].state = 0;
2539 }
2540 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2541 if (j->cadence_f[cnt].state == 1) {
2542 if(!j->cadence_f[cnt].on1) {
2543 j->cadence_f[cnt].state = 7;
2544 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2545 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2546 if(j->cadence_f[cnt].off1) {
2547 j->cadence_f[cnt].state = 2;
2548 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2549 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2550 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2551 } else {
2552 j->cadence_f[cnt].state = 7;
2553 }
2554 } else {
2555 j->cadence_f[cnt].state = 0;
2556 }
2557 } else if (j->cadence_f[cnt].state == 3) {
2558 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2559 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2560 if(j->cadence_f[cnt].off2) {
2561 j->cadence_f[cnt].state = 4;
2562 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2563 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2564 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2565 } else {
2566 j->cadence_f[cnt].state = 7;
2567 }
2568 } else {
2569 j->cadence_f[cnt].state = 0;
2570 }
2571 } else if (j->cadence_f[cnt].state == 5) {
2572 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2573 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2574 if(j->cadence_f[cnt].off3) {
2575 j->cadence_f[cnt].state = 6;
2576 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2577 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2578 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2579 } else {
2580 j->cadence_f[cnt].state = 7;
2581 }
2582 } else {
2583 j->cadence_f[cnt].state = 0;
2584 }
2585 } else {
2586 j->cadence_f[cnt].state = 0;
2587 }
2588 } else {
2589 switch(j->cadence_f[cnt].state) {
2590 case 1:
2591 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2592 !j->cadence_f[cnt].off1 &&
2593 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2594 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2595 j->cadence_f[cnt].state = 7;
2596 }
2597 break;
2598 case 3:
2599 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2600 !j->cadence_f[cnt].off2 &&
2601 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2602 j->cadence_f[cnt].state = 7;
2603 }
2604 break;
2605 case 5:
2606 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2607 !j->cadence_f[cnt].off3) {
2608 j->cadence_f[cnt].state = 7;
2609 }
2610 break;
2611 }
2612 }
2613
2614 if (ixjdebug & 0x0040) {
2615 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2616 switch(j->cadence_f[cnt].state) {
2617 case 0:
2618 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2619 break;
2620 case 1:
2621 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2622 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2623 break;
2624 case 2:
2625 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2626 j->cadence_f[cnt].off1max);
2627 break;
2628 case 3:
2629 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2630 j->cadence_f[cnt].on2max);
2631 break;
2632 case 4:
2633 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2634 j->cadence_f[cnt].off2max);
2635 break;
2636 case 5:
2637 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2638 j->cadence_f[cnt].on3max);
2639 break;
2640 case 6:
2641 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2642 j->cadence_f[cnt].off3max);
2643 break;
2644 }
2645 }
2646 }
2647 if (j->cadence_f[cnt].state == 7) {
2648 j->cadence_f[cnt].state = 0;
2649 if (j->cadence_f[cnt].enable == 1)
2650 j->cadence_f[cnt].enable = 0;
2651 switch (cnt) {
2652 case 0:
2653 if(ixjdebug & 0x0020) {
2654 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2655 }
2656 j->ex.bits.fc0 = 1;
2657 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2658 break;
2659 case 1:
2660 if(ixjdebug & 0x0020) {
2661 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2662 }
2663 j->ex.bits.fc1 = 1;
2664 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2665 break;
2666 case 2:
2667 if(ixjdebug & 0x0020) {
2668 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2669 }
2670 j->ex.bits.fc2 = 1;
2671 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2672 break;
2673 case 3:
2674 if(ixjdebug & 0x0020) {
2675 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2676 }
2677 j->ex.bits.fc3 = 1;
2678 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2679 break;
2680 }
2681 }
2682 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2683 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2684 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2685 trg = 1;
2686 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2687 trg = 0;
2688 }
2689 switch (cnt) {
2690 case 0:
2691 if(ixjdebug & 0x0020) {
2692 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2693 }
2694 j->ex.bits.f0 = 1;
2695 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2696 break;
2697 case 1:
2698 if(ixjdebug & 0x0020) {
2699 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2700 }
2701 j->ex.bits.f1 = 1;
2702 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2703 break;
2704 case 2:
2705 if(ixjdebug & 0x0020) {
2706 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2707 }
2708 j->ex.bits.f2 = 1;
2709 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2710 break;
2711 case 3:
2712 if(ixjdebug & 0x0020) {
2713 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2714 }
2715 j->ex.bits.f3 = 1;
2716 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2717 break;
2718 }
2719 }
2720 }
2721 return 0;
2722 }
2723
2724 static int LineMonitor(IXJ *j)
2725 {
2726 if (j->dtmf_proc) {
2727 return -1;
2728 }
2729 j->dtmf_proc = 1;
2730
2731 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2732 return -1;
2733
2734 j->dtmf.bytes.high = j->ssr.high;
2735 j->dtmf.bytes.low = j->ssr.low;
2736 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2737 j->dtmf_state = 1;
2738 j->dtmf_current = j->dtmf.bits.digit;
2739 }
2740 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2741 {
2742 if(!j->cidcw_wait) {
2743 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2744 j->dtmf_wp++;
2745 if (j->dtmf_wp == 79)
2746 j->dtmf_wp = 0;
2747 j->ex.bits.dtmf_ready = 1;
2748 if(j->ex_sig.bits.dtmf_ready) {
2749 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2750 }
2751 }
2752 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2753 if(ixjdebug & 0x0020) {
2754 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2755 }
2756 j->flags.cidcw_ack = 1;
2757 }
2758 j->dtmf_state = 0;
2759 }
2760 j->dtmf_proc = 0;
2761
2762 return 0;
2763 }
2764
2765 /************************************************************************
2766 *
2767 * Functions to allow alaw <-> ulaw conversions.
2768 *
2769 ************************************************************************/
2770
2771 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2772 {
2773 static unsigned char table_ulaw2alaw[] =
2774 {
2775 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2776 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2777 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2778 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2779 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2780 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2781 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2782 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2783 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2784 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2785 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2786 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2787 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2788 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2789 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2790 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2791 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2792 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2793 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2794 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2795 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2796 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2797 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2798 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2799 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2800 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2801 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2802 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2803 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2804 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2805 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2806 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2807 };
2808
2809 while (len--)
2810 *buff++ = table_ulaw2alaw[*(unsigned char *)buff];
2811 }
2812
2813 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2814 {
2815 static unsigned char table_alaw2ulaw[] =
2816 {
2817 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2818 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2819 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2820 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2821 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2822 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2823 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2824 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2825 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2826 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2827 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2828 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2829 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2830 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2831 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2832 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2833 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2834 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2835 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2836 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2837 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2838 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2839 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2840 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2841 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2842 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2843 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2844 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2845 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2846 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2847 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2848 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2849 };
2850
2851 while (len--)
2852 *buff++ = table_alaw2ulaw[*(unsigned char *)buff];
2853 }
2854
2855 static ssize_t ixj_read(struct file * file_p, char *buf, size_t length, loff_t * ppos)
2856 {
2857 unsigned long i = *ppos;
2858 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode->i_rdev));
2859
2860 DECLARE_WAITQUEUE(wait, current);
2861
2862 if (j->flags.inread)
2863 return -EALREADY;
2864
2865 j->flags.inread = 1;
2866
2867 add_wait_queue(&j->read_q, &wait);
2868 set_current_state(TASK_INTERRUPTIBLE);
2869 mb();
2870
2871 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2872 ++j->read_wait;
2873 if (file_p->f_flags & O_NONBLOCK) {
2874 set_current_state(TASK_RUNNING);
2875 remove_wait_queue(&j->read_q, &wait);
2876 j->flags.inread = 0;
2877 return -EAGAIN;
2878 }
2879 if (!ixj_hookstate(j)) {
2880 set_current_state(TASK_RUNNING);
2881 remove_wait_queue(&j->read_q, &wait);
2882 j->flags.inread = 0;
2883 return 0;
2884 }
2885 interruptible_sleep_on(&j->read_q);
2886 if (signal_pending(current)) {
2887 set_current_state(TASK_RUNNING);
2888 remove_wait_queue(&j->read_q, &wait);
2889 j->flags.inread = 0;
2890 return -EINTR;
2891 }
2892 }
2893
2894 remove_wait_queue(&j->read_q, &wait);
2895 set_current_state(TASK_RUNNING);
2896 /* Don't ever copy more than the user asks */
2897 if(j->rec_codec == ALAW)
2898 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2899 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2900 j->read_buffer_ready = 0;
2901 if (i) {
2902 j->flags.inread = 0;
2903 return -EFAULT;
2904 } else {
2905 j->flags.inread = 0;
2906 return min(length, j->read_buffer_size);
2907 }
2908 }
2909
2910 static ssize_t ixj_enhanced_read(struct file * file_p, char *buf, size_t length,
2911 loff_t * ppos)
2912 {
2913 int pre_retval;
2914 ssize_t read_retval = 0;
2915 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode->i_rdev));
2916
2917 pre_retval = ixj_PreRead(j, 0L);
2918 switch (pre_retval) {
2919 case NORMAL:
2920 read_retval = ixj_read(file_p, buf, length, ppos);
2921 ixj_PostRead(j, 0L);
2922 break;
2923 case NOPOST:
2924 read_retval = ixj_read(file_p, buf, length, ppos);
2925 break;
2926 case POSTONLY:
2927 ixj_PostRead(j, 0L);
2928 break;
2929 default:
2930 read_retval = pre_retval;
2931 }
2932 return read_retval;
2933 }
2934
2935 static ssize_t ixj_write(struct file *file_p, const char *buf, size_t count, loff_t * ppos)
2936 {
2937 unsigned long i = *ppos;
2938 IXJ *j = file_p->private_data;
2939
2940 DECLARE_WAITQUEUE(wait, current);
2941
2942 if (j->flags.inwrite)
2943 return -EALREADY;
2944
2945 j->flags.inwrite = 1;
2946
2947 add_wait_queue(&j->write_q, &wait);
2948 set_current_state(TASK_INTERRUPTIBLE);
2949 mb();
2950
2951
2952 while (!j->write_buffers_empty) {
2953 ++j->write_wait;
2954 if (file_p->f_flags & O_NONBLOCK) {
2955 set_current_state(TASK_RUNNING);
2956 remove_wait_queue(&j->write_q, &wait);
2957 j->flags.inwrite = 0;
2958 return -EAGAIN;
2959 }
2960 if (!ixj_hookstate(j)) {
2961 set_current_state(TASK_RUNNING);
2962 remove_wait_queue(&j->write_q, &wait);
2963 j->flags.inwrite = 0;
2964 return 0;
2965 }
2966 interruptible_sleep_on(&j->write_q);
2967 if (signal_pending(current)) {
2968 set_current_state(TASK_RUNNING);
2969 remove_wait_queue(&j->write_q, &wait);
2970 j->flags.inwrite = 0;
2971 return -EINTR;
2972 }
2973 }
2974 set_current_state(TASK_RUNNING);
2975 remove_wait_queue(&j->write_q, &wait);
2976 if (j->write_buffer_wp + count >= j->write_buffer_end)
2977 j->write_buffer_wp = j->write_buffer;
2978 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2979 if (i) {
2980 j->flags.inwrite = 0;
2981 return -EFAULT;
2982 }
2983 if(j->play_codec == ALAW)
2984 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2985 j->flags.inwrite = 0;
2986 return min(count, j->write_buffer_size);
2987 }
2988
2989 static ssize_t ixj_enhanced_write(struct file * file_p, const char *buf, size_t count, loff_t * ppos)
2990 {
2991 int pre_retval;
2992 ssize_t write_retval = 0;
2993
2994 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode->i_rdev));
2995
2996 pre_retval = ixj_PreWrite(j, 0L);
2997 switch (pre_retval) {
2998 case NORMAL:
2999 write_retval = ixj_write(file_p, buf, count, ppos);
3000 if (write_retval > 0) {
3001 ixj_PostWrite(j, 0L);
3002 j->write_buffer_wp += write_retval;
3003 j->write_buffers_empty--;
3004 }
3005 break;
3006 case NOPOST:
3007 write_retval = ixj_write(file_p, buf, count, ppos);
3008 if (write_retval > 0) {
3009 j->write_buffer_wp += write_retval;
3010 j->write_buffers_empty--;
3011 }
3012 break;
3013 case POSTONLY:
3014 ixj_PostWrite(j, 0L);
3015 break;
3016 default:
3017 write_retval = pre_retval;
3018 }
3019 return write_retval;
3020 }
3021
3022 static void ixj_read_frame(IXJ *j)
3023 {
3024 int cnt, dly;
3025
3026 if (j->read_buffer) {
3027 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3028 if (!(cnt % 16) && !IsRxReady(j)) {
3029 dly = 0;
3030 while (!IsRxReady(j)) {
3031 if (dly++ > 5) {
3032 dly = 0;
3033 break;
3034 }
3035 udelay(10);
3036 }
3037 }
3038 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
3039 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3040 inb_p(j->DSPbase + 0x0E);
3041 inb_p(j->DSPbase + 0x0F);
3042 }
3043 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
3044 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
3045 }
3046 ++j->framesread;
3047 if (j->intercom != -1) {
3048 if (IsTxReady(get_ixj(j->intercom))) {
3049 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3050 if (!(cnt % 16) && !IsTxReady(j)) {
3051 dly = 0;
3052 while (!IsTxReady(j)) {
3053 if (dly++ > 5) {
3054 dly = 0;
3055 break;
3056 }
3057 udelay(10);
3058 }
3059 }
3060 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
3061 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
3062 }
3063 get_ixj(j->intercom)->frameswritten++;
3064 }
3065 } else {
3066 j->read_buffer_ready = 1;
3067 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
3068
3069 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3070
3071 if(j->ixj_signals[SIG_READ_READY])
3072 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
3073 }
3074 }
3075 }
3076
3077 static short fsk[][6][20] =
3078 {
3079 {
3080 {
3081 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
3082 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
3083 },
3084 {
3085 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
3086 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
3087 },
3088 {
3089 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
3090 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
3091 },
3092 {
3093 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
3094 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
3095 },
3096 {
3097 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3098 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3099 },
3100 {
3101 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3102 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3103 }
3104 },
3105 {
3106 {
3107 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3108 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3109 },
3110 {
3111 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3112 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3113 },
3114 {
3115 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3116 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3117 },
3118 {
3119 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3120 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3121 },
3122 {
3123 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3124 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3125 },
3126 {
3127 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3128 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3129 }
3130 }
3131 };
3132
3133
3134 static void ixj_write_cid_bit(IXJ *j, int bit)
3135 {
3136 while (j->fskcnt < 20) {
3137 if(j->fskdcnt < (j->fsksize - 1))
3138 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3139
3140 j->fskcnt += 3;
3141 }
3142 j->fskcnt %= 20;
3143
3144 if (!bit)
3145 j->fskz++;
3146 if (j->fskz >= 6)
3147 j->fskz = 0;
3148
3149 }
3150
3151 static void ixj_write_cid_byte(IXJ *j, char byte)
3152 {
3153 IXJ_CBYTE cb;
3154
3155 cb.cbyte = byte;
3156 ixj_write_cid_bit(j, 0);
3157 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3158 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3159 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3160 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3161 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3162 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3163 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3164 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3165 ixj_write_cid_bit(j, 1);
3166 }
3167
3168 static void ixj_write_cid_seize(IXJ *j)
3169 {
3170 int cnt;
3171
3172 for (cnt = 0; cnt < 150; cnt++) {
3173 ixj_write_cid_bit(j, 0);
3174 ixj_write_cid_bit(j, 1);
3175 }
3176 for (cnt = 0; cnt < 180; cnt++) {
3177 ixj_write_cid_bit(j, 1);
3178 }
3179 }
3180
3181 static void ixj_write_cidcw_seize(IXJ *j)
3182 {
3183 int cnt;
3184
3185 for (cnt = 0; cnt < 80; cnt++) {
3186 ixj_write_cid_bit(j, 1);
3187 }
3188 }
3189
3190 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3191 {
3192 int cnt;
3193
3194 for (cnt = 0; cnt < strlen(s); cnt++) {
3195 ixj_write_cid_byte(j, s[cnt]);
3196 checksum = (checksum + s[cnt]);
3197 }
3198 return checksum;
3199 }
3200
3201 static void ixj_pad_fsk(IXJ *j, int pad)
3202 {
3203 int cnt;
3204
3205 for (cnt = 0; cnt < pad; cnt++) {
3206 if(j->fskdcnt < (j->fsksize - 1))
3207 j->fskdata[j->fskdcnt++] = 0x0000;
3208 }
3209 for (cnt = 0; cnt < 720; cnt++) {
3210 if(j->fskdcnt < (j->fsksize - 1))
3211 j->fskdata[j->fskdcnt++] = 0x0000;
3212 }
3213 }
3214
3215 static void ixj_pre_cid(IXJ *j)
3216 {
3217 j->cid_play_codec = j->play_codec;
3218 j->cid_play_frame_size = j->play_frame_size;
3219 j->cid_play_volume = get_play_volume(j);
3220 j->cid_play_flag = j->flags.playing;
3221
3222 j->cid_rec_codec = j->rec_codec;
3223 j->cid_rec_volume = get_rec_volume(j);
3224 j->cid_rec_flag = j->flags.recording;
3225
3226 j->cid_play_aec_level = j->aec_level;
3227
3228 switch(j->baseframe.low) {
3229 case 0xA0:
3230 j->cid_base_frame_size = 20;
3231 break;
3232 case 0x50:
3233 j->cid_base_frame_size = 10;
3234 break;
3235 case 0xF0:
3236 j->cid_base_frame_size = 30;
3237 break;
3238 }
3239
3240 ixj_play_stop(j);
3241 ixj_cpt_stop(j);
3242
3243 j->flags.cidplay = 1;
3244
3245 set_base_frame(j, 30);
3246 set_play_codec(j, LINEAR16);
3247 set_play_volume(j, 0x1B);
3248 ixj_play_start(j);
3249 }
3250
3251 static void ixj_post_cid(IXJ *j)
3252 {
3253 ixj_play_stop(j);
3254
3255 if(j->cidsize > 5000) {
3256 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3257 }
3258 j->flags.cidplay = 0;
3259 if(ixjdebug & 0x0200) {
3260 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3261 }
3262
3263 ixj_fsk_free(j);
3264
3265 j->fskdcnt = 0;
3266 set_base_frame(j, j->cid_base_frame_size);
3267 set_play_codec(j, j->cid_play_codec);
3268 ixj_aec_start(j, j->cid_play_aec_level);
3269 set_play_volume(j, j->cid_play_volume);
3270
3271 set_rec_codec(j, j->cid_rec_codec);
3272 set_rec_volume(j, j->cid_rec_volume);
3273
3274 if(j->cid_rec_flag)
3275 ixj_record_start(j);
3276
3277 if(j->cid_play_flag)
3278 ixj_play_start(j);
3279
3280 if(j->cid_play_flag) {
3281 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3282 }
3283 }
3284
3285 static void ixj_write_cid(IXJ *j)
3286 {
3287 char sdmf1[50];
3288 char sdmf2[50];
3289 char sdmf3[80];
3290 char mdmflen, len1, len2, len3;
3291 int pad;
3292
3293 int checksum = 0;
3294
3295 if (j->dsp.low == 0x20 || j->flags.cidplay)
3296 return;
3297
3298 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3299 j->cidsize = j->cidcnt = 0;
3300
3301 ixj_fsk_alloc(j);
3302
3303 strcpy(sdmf1, j->cid_send.month);
3304 strcat(sdmf1, j->cid_send.day);
3305 strcat(sdmf1, j->cid_send.hour);
3306 strcat(sdmf1, j->cid_send.min);
3307 strcpy(sdmf2, j->cid_send.number);
3308 strcpy(sdmf3, j->cid_send.name);
3309
3310 len1 = strlen(sdmf1);
3311 len2 = strlen(sdmf2);
3312 len3 = strlen(sdmf3);
3313 mdmflen = len1 + len2 + len3 + 6;
3314
3315 while(1){
3316 ixj_write_cid_seize(j);
3317
3318 ixj_write_cid_byte(j, 0x80);
3319 checksum = 0x80;
3320 ixj_write_cid_byte(j, mdmflen);
3321 checksum = checksum + mdmflen;
3322
3323 ixj_write_cid_byte(j, 0x01);
3324 checksum = checksum + 0x01;
3325 ixj_write_cid_byte(j, len1);
3326 checksum = checksum + len1;
3327 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3328 if(ixj_hookstate(j) & 1)
3329 break;
3330
3331 ixj_write_cid_byte(j, 0x02);
3332 checksum = checksum + 0x02;
3333 ixj_write_cid_byte(j, len2);
3334 checksum = checksum + len2;
3335 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3336 if(ixj_hookstate(j) & 1)
3337 break;
3338
3339 ixj_write_cid_byte(j, 0x07);
3340 checksum = checksum + 0x07;
3341 ixj_write_cid_byte(j, len3);
3342 checksum = checksum + len3;
3343 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3344 if(ixj_hookstate(j) & 1)
3345 break;
3346
3347 checksum %= 256;
3348 checksum ^= 0xFF;
3349 checksum += 1;
3350
3351 ixj_write_cid_byte(j, (char) checksum);
3352
3353 pad = j->fskdcnt % 240;
3354 if (pad) {
3355 pad = 240 - pad;
3356 }
3357 ixj_pad_fsk(j, pad);
3358 break;
3359 }
3360
3361 ixj_write_frame(j);
3362 }
3363
3364 static void ixj_write_cidcw(IXJ *j)
3365 {
3366 IXJ_TONE ti;
3367
3368 char sdmf1[50];
3369 char sdmf2[50];
3370 char sdmf3[80];
3371 char mdmflen, len1, len2, len3;
3372 int pad;
3373
3374 int checksum = 0;
3375
3376 if (j->dsp.low == 0x20 || j->flags.cidplay)
3377 return;
3378
3379 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3380 j->cidsize = j->cidcnt = 0;
3381
3382 ixj_fsk_alloc(j);
3383
3384 j->flags.cidcw_ack = 0;
3385
3386 ti.tone_index = 23;
3387 ti.gain0 = 1;
3388 ti.freq0 = hz440;
3389 ti.gain1 = 0;
3390 ti.freq1 = 0;
3391 ixj_init_tone(j, &ti);
3392
3393 ixj_set_tone_on(1500, j);
3394 ixj_set_tone_off(32, j);
3395 if(ixjdebug & 0x0200) {
3396 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3397 }
3398 ixj_play_tone(j, 23);
3399
3400 clear_bit(j->board, &j->busyflags);
3401 while(j->tone_state) {
3402 set_current_state(TASK_INTERRUPTIBLE);
3403 schedule_timeout(1);
3404 }
3405 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3406 set_current_state(TASK_INTERRUPTIBLE);
3407 schedule_timeout(1);
3408 }
3409 if(ixjdebug & 0x0200) {
3410 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3411 }
3412
3413 ti.tone_index = 24;
3414 ti.gain0 = 1;
3415 ti.freq0 = hz2130;
3416 ti.gain1 = 0;
3417 ti.freq1 = hz2750;
3418 ixj_init_tone(j, &ti);
3419
3420 ixj_set_tone_off(10, j);
3421 ixj_set_tone_on(600, j);
3422 if(ixjdebug & 0x0200) {
3423 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3424 }
3425 ixj_play_tone(j, 24);
3426
3427 clear_bit(j->board, &j->busyflags);
3428 while(j->tone_state) {
3429 set_current_state(TASK_INTERRUPTIBLE);
3430 schedule_timeout(1);
3431 }
3432 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3433 set_current_state(TASK_INTERRUPTIBLE);
3434 schedule_timeout(1);
3435 }
3436 if(ixjdebug & 0x0200) {
3437 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3438 }
3439
3440 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3441
3442 clear_bit(j->board, &j->busyflags);
3443 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3444 set_current_state(TASK_INTERRUPTIBLE);
3445 schedule_timeout(1);
3446 }
3447 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3448 set_current_state(TASK_INTERRUPTIBLE);
3449 schedule_timeout(1);
3450 }
3451 j->cidcw_wait = 0;
3452 if(!j->flags.cidcw_ack) {
3453 if(ixjdebug & 0x0200) {
3454 printk("IXJ cidcw phone%d did not recieve ACK from display %ld\n", j->board, jiffies);
3455 }
3456 ixj_post_cid(j);
3457 if(j->cid_play_flag) {
3458 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3459 }
3460 return;
3461 } else {
3462 ixj_pre_cid(j);
3463 }
3464 j->flags.cidcw_ack = 0;
3465 strcpy(sdmf1, j->cid_send.month);
3466 strcat(sdmf1, j->cid_send.day);
3467 strcat(sdmf1, j->cid_send.hour);
3468 strcat(sdmf1, j->cid_send.min);
3469 strcpy(sdmf2, j->cid_send.number);
3470 strcpy(sdmf3, j->cid_send.name);
3471
3472 len1 = strlen(sdmf1);
3473 len2 = strlen(sdmf2);
3474 len3 = strlen(sdmf3);
3475 mdmflen = len1 + len2 + len3 + 6;
3476
3477 ixj_write_cidcw_seize(j);
3478
3479 ixj_write_cid_byte(j, 0x80);
3480 checksum = 0x80;
3481 ixj_write_cid_byte(j, mdmflen);
3482 checksum = checksum + mdmflen;
3483
3484 ixj_write_cid_byte(j, 0x01);
3485 checksum = checksum + 0x01;
3486 ixj_write_cid_byte(j, len1);
3487 checksum = checksum + len1;
3488 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3489
3490 ixj_write_cid_byte(j, 0x02);
3491 checksum = checksum + 0x02;
3492 ixj_write_cid_byte(j, len2);
3493 checksum = checksum + len2;
3494 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3495
3496 ixj_write_cid_byte(j, 0x07);
3497 checksum = checksum + 0x07;
3498 ixj_write_cid_byte(j, len3);
3499 checksum = checksum + len3;
3500 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3501
3502 checksum %= 256;
3503 checksum ^= 0xFF;
3504 checksum += 1;
3505
3506 ixj_write_cid_byte(j, (char) checksum);
3507
3508 pad = j->fskdcnt % 240;
3509 if (pad) {
3510 pad = 240 - pad;
3511 }
3512 ixj_pad_fsk(j, pad);
3513 if(ixjdebug & 0x0200) {
3514 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3515 }
3516 }
3517
3518 static void ixj_write_vmwi(IXJ *j, int msg)
3519 {
3520 char mdmflen;
3521 int pad;
3522
3523 int checksum = 0;
3524
3525 if (j->dsp.low == 0x20 || j->flags.cidplay)
3526 return;
3527
3528 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3529 j->cidsize = j->cidcnt = 0;
3530
3531 ixj_fsk_alloc(j);
3532
3533 mdmflen = 3;
3534
3535 if (j->port == PORT_POTS)
3536 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3537
3538 ixj_write_cid_seize(j);
3539
3540 ixj_write_cid_byte(j, 0x82);
3541 checksum = 0x82;
3542 ixj_write_cid_byte(j, mdmflen);
3543 checksum = checksum + mdmflen;
3544
3545 ixj_write_cid_byte(j, 0x0B);
3546 checksum = checksum + 0x0B;
3547 ixj_write_cid_byte(j, 1);
3548 checksum = checksum + 1;
3549
3550 if(msg) {
3551 ixj_write_cid_byte(j, 0xFF);
3552 checksum = checksum + 0xFF;
3553 }
3554 else {
3555 ixj_write_cid_byte(j, 0x00);
3556 checksum = checksum + 0x00;
3557 }
3558
3559 checksum %= 256;
3560 checksum ^= 0xFF;
3561 checksum += 1;
3562
3563 ixj_write_cid_byte(j, (char) checksum);
3564
3565 pad = j->fskdcnt % 240;
3566 if (pad) {
3567 pad = 240 - pad;
3568 }
3569 ixj_pad_fsk(j, pad);
3570 }
3571
3572 static void ixj_write_frame(IXJ *j)
3573 {
3574 int cnt, frame_count, dly;
3575 IXJ_WORD dat;
3576 BYTES blankword;
3577
3578 frame_count = 0;
3579 if(j->flags.cidplay) {
3580 for(cnt = 0; cnt < 480; cnt++) {
3581 if (!(cnt % 16) && !IsTxReady(j)) {
3582 dly = 0;
3583 while (!IsTxReady(j)) {
3584 if (dly++ > 5) {
3585 dly = 0;
3586 break;
3587 }
3588 udelay(10);
3589 }
3590 }
3591 dat.word = j->fskdata[j->cidcnt++];
3592 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3593 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3594 cnt++;
3595 }
3596 if(j->cidcnt >= j->fskdcnt) {
3597 ixj_post_cid(j);
3598 }
3599 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3600 and there is real audio data in the buffer, we need to throw it away because
3601 we just used it's time slot */
3602 if (j->write_buffer_rp > j->write_buffer_wp) {
3603 j->write_buffer_rp += j->cid_play_frame_size * 2;
3604 if (j->write_buffer_rp >= j->write_buffer_end) {
3605 j->write_buffer_rp = j->write_buffer;
3606 }
3607 j->write_buffers_empty++;
3608 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3609
3610 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3611 }
3612 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3613 if (j->write_buffer_wp > j->write_buffer_rp) {
3614 frame_count =
3615 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3616 }
3617 if (j->write_buffer_rp > j->write_buffer_wp) {
3618 frame_count =
3619 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3620 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3621 }
3622 if (frame_count >= 1) {
3623 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3624 switch (j->play_mode) {
3625 case PLAYBACK_MODE_ULAW:
3626 case PLAYBACK_MODE_ALAW:
3627 blankword.low = blankword.high = 0xFF;
3628 break;
3629 case PLAYBACK_MODE_8LINEAR:
3630 case PLAYBACK_MODE_16LINEAR:
3631 blankword.low = blankword.high = 0x00;
3632 break;
3633 case PLAYBACK_MODE_8LINEAR_WSS:
3634 blankword.low = blankword.high = 0x80;
3635 break;
3636 }
3637 for (cnt = 0; cnt < 16; cnt++) {
3638 if (!(cnt % 16) && !IsTxReady(j)) {
3639 dly = 0;
3640 while (!IsTxReady(j)) {
3641 if (dly++ > 5) {
3642 dly = 0;
3643 break;
3644 }
3645 udelay(10);
3646 }
3647 }
3648 outb_p((blankword.low), j->DSPbase + 0x0C);
3649 outb_p((blankword.high), j->DSPbase + 0x0D);
3650 }
3651 j->flags.play_first_frame = 0;
3652 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3653 for (cnt = 0; cnt < 24; cnt++) {
3654 if(cnt == 12) {
3655 blankword.low = 0x02;
3656 blankword.high = 0x00;
3657 }
3658 else {
3659 blankword.low = blankword.high = 0x00;
3660 }
3661 if (!(cnt % 16) && !IsTxReady(j)) {
3662 dly = 0;
3663 while (!IsTxReady(j)) {
3664 if (dly++ > 5) {
3665 dly = 0;
3666 break;
3667 }
3668 udelay(10);
3669 }
3670 }
3671 outb_p((blankword.low), j->DSPbase + 0x0C);
3672 outb_p((blankword.high), j->DSPbase + 0x0D);
3673 }
3674 j->flags.play_first_frame = 0;
3675 }
3676 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3677 if (!(cnt % 16) && !IsTxReady(j)) {
3678 dly = 0;
3679 while (!IsTxReady(j)) {
3680 if (dly++ > 5) {
3681 dly = 0;
3682 break;
3683 }
3684 udelay(10);
3685 }
3686 }
3687 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3688 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3689 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3690 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3691 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3692 j->write_buffer_rp + cnt + 9 == 0) {
3693 /* someone is trying to write silence lets make this a type 0 frame. */
3694 outb_p(0x00, j->DSPbase + 0x0C);
3695 outb_p(0x00, j->DSPbase + 0x0D);
3696 } else {
3697 /* so all other frames are type 1. */
3698 outb_p(0x01, j->DSPbase + 0x0C);
3699 outb_p(0x00, j->DSPbase + 0x0D);
3700 }
3701 }
3702 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3703 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3704 *(j->write_buffer_rp + cnt) = 0;
3705 *(j->write_buffer_rp + cnt + 1) = 0;
3706 }
3707 j->write_buffer_rp += j->play_frame_size * 2;
3708 if (j->write_buffer_rp >= j->write_buffer_end) {
3709 j->write_buffer_rp = j->write_buffer;
3710 }
3711 j->write_buffers_empty++;
3712 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3713
3714 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3715
3716 ++j->frameswritten;
3717 }
3718 } else {
3719 j->drybuffer++;
3720 }
3721 if(j->ixj_signals[SIG_WRITE_READY]) {
3722 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3723 }
3724 }
3725
3726 static int idle(IXJ *j)
3727 {
3728 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3729
3730 return 0;
3731
3732 if (j->ssr.high || j->ssr.low) {
3733 return 0;
3734 } else {
3735 j->play_mode = -1;
3736 j->flags.playing = 0;
3737 j->rec_mode = -1;
3738 j->flags.recording = 0;
3739 return 1;
3740 }
3741 }
3742
3743 static int set_base_frame(IXJ *j, int size)
3744 {
3745 unsigned short cmd;
3746 int cnt;
3747
3748 idle(j);
3749 j->cid_play_aec_level = j->aec_level;
3750 aec_stop(j);
3751 for (cnt = 0; cnt < 10; cnt++) {
3752 if (idle(j))
3753 break;
3754 }
3755 if (j->ssr.high || j->ssr.low)
3756 return -1;
3757 if (j->dsp.low != 0x20) {
3758 switch (size) {
3759 case 30:
3760 cmd = 0x07F0;
3761 /* Set Base Frame Size to 240 pg9-10 8021 */
3762 break;
3763 case 20:
3764 cmd = 0x07A0;
3765 /* Set Base Frame Size to 160 pg9-10 8021 */
3766 break;
3767 case 10:
3768 cmd = 0x0750;
3769 /* Set Base Frame Size to 80 pg9-10 8021 */
3770 break;
3771 default:
3772 return -1;
3773 }
3774 } else {
3775 if (size == 30)
3776 return size;
3777 else
3778 return -1;
3779 }
3780 if (ixj_WriteDSPCommand(cmd, j)) {
3781 j->baseframe.high = j->baseframe.low = 0xFF;
3782 return -1;
3783 } else {
3784 j->baseframe.high = j->ssr.high;
3785 j->baseframe.low = j->ssr.low;
3786 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3787 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3788 return -1;
3789 }
3790 }
3791 ixj_aec_start(j, j->cid_play_aec_level);
3792 return size;
3793 }
3794
3795 static int set_rec_codec(IXJ *j, int rate)
3796 {
3797 int retval = 0;
3798
3799 j->rec_codec = rate;
3800
3801 switch (rate) {
3802 case G723_63:
3803 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3804 j->rec_frame_size = 12;
3805 j->rec_mode = 0;
3806 } else {
3807 retval = 1;
3808 }
3809 break;
3810 case G723_53:
3811 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3812 j->rec_frame_size = 10;
3813 j->rec_mode = 0;
3814 } else {
3815 retval = 1;
3816 }
3817 break;
3818 case TS85:
3819 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3820 j->rec_frame_size = 16;
3821 j->rec_mode = 0;
3822 } else {
3823 retval = 1;
3824 }
3825 break;
3826 case TS48:
3827 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3828 j->rec_frame_size = 9;
3829 j->rec_mode = 0;
3830 } else {
3831 retval = 1;
3832 }
3833 break;
3834 case TS41:
3835 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3836 j->rec_frame_size = 8;
3837 j->rec_mode = 0;
3838 } else {
3839 retval = 1;
3840 }
3841 break;
3842 case G728:
3843 if (j->dsp.low != 0x20) {
3844 j->rec_frame_size = 48;
3845 j->rec_mode = 0;
3846 } else {
3847 retval = 1;
3848 }
3849 break;
3850 case G729:
3851 if (j->dsp.low != 0x20) {
3852 if (!j->flags.g729_loaded) {
3853 retval = 1;
3854 break;
3855 }
3856 switch (j->baseframe.low) {
3857 case 0xA0:
3858 j->rec_frame_size = 10;
3859 break;
3860 case 0x50:
3861 j->rec_frame_size = 5;
3862 break;
3863 default:
3864 j->rec_frame_size = 15;
3865 break;
3866 }
3867 j->rec_mode = 0;
3868 } else {
3869 retval = 1;
3870 }
3871 break;
3872 case G729B:
3873 if (j->dsp.low != 0x20) {
3874 if (!j->flags.g729_loaded) {
3875 retval = 1;
3876 break;
3877 }
3878 switch (j->baseframe.low) {
3879 case 0xA0:
3880 j->rec_frame_size = 12;
3881 break;
3882 case 0x50:
3883 j->rec_frame_size = 6;
3884 break;
3885 default:
3886 j->rec_frame_size = 18;
3887 break;
3888 }
3889 j->rec_mode = 0;
3890 } else {
3891 retval = 1;
3892 }
3893 break;
3894 case ULAW:
3895 switch (j->baseframe.low) {
3896 case 0xA0:
3897 j->rec_frame_size = 80;
3898 break;
3899 case 0x50:
3900 j->rec_frame_size = 40;
3901 break;
3902 default:
3903 j->rec_frame_size = 120;
3904 break;
3905 }
3906 j->rec_mode = 4;
3907 break;
3908 case ALAW:
3909 switch (j->baseframe.low) {
3910 case 0xA0:
3911 j->rec_frame_size = 80;
3912 break;
3913 case 0x50:
3914 j->rec_frame_size = 40;
3915 break;
3916 default:
3917 j->rec_frame_size = 120;
3918 break;
3919 }
3920 j->rec_mode = 4;
3921 break;
3922 case LINEAR16:
3923 switch (j->baseframe.low) {
3924 case 0xA0:
3925 j->rec_frame_size = 160;
3926 break;
3927 case 0x50:
3928 j->rec_frame_size = 80;
3929 break;
3930 default:
3931 j->rec_frame_size = 240;
3932 break;
3933 }
3934 j->rec_mode = 5;
3935 break;
3936 case LINEAR8:
3937 switch (j->baseframe.low) {
3938 case 0xA0:
3939 j->rec_frame_size = 80;
3940 break;
3941 case 0x50:
3942 j->rec_frame_size = 40;
3943 break;
3944 default:
3945 j->rec_frame_size = 120;
3946 break;
3947 }
3948 j->rec_mode = 6;
3949 break;
3950 case WSS:
3951 switch (j->baseframe.low) {
3952 case 0xA0:
3953 j->rec_frame_size = 80;
3954 break;
3955 case 0x50:
3956 j->rec_frame_size = 40;
3957 break;
3958 default:
3959 j->rec_frame_size = 120;
3960 break;
3961 }
3962 j->rec_mode = 7;
3963 break;
3964 default:
3965 j->rec_frame_size = 0;
3966 j->rec_mode = -1;
3967 if (j->read_buffer) {
3968 kfree(j->read_buffer);
3969 j->read_buffer = NULL;
3970 j->read_buffer_size = 0;
3971 }
3972 retval = 1;
3973 break;
3974 }
3975 return retval;
3976 }
3977
3978 static int ixj_record_start(IXJ *j)
3979 {
3980 unsigned short cmd = 0x0000;
3981
3982 if (j->read_buffer) {
3983 ixj_record_stop(j);
3984 }
3985 j->flags.recording = 1;
3986 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3987
3988 if(ixjdebug & 0x0002)
3989 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3990
3991 if (!j->rec_mode) {
3992 switch (j->rec_codec) {
3993 case G723_63:
3994 cmd = 0x5131;
3995 break;
3996 case G723_53:
3997 cmd = 0x5132;
3998 break;
3999 case TS85:
4000 cmd = 0x5130; /* TrueSpeech 8.5 */
4001
4002 break;
4003 case TS48:
4004 cmd = 0x5133; /* TrueSpeech 4.8 */
4005
4006 break;
4007 case TS41:
4008 cmd = 0x5134; /* TrueSpeech 4.1 */
4009
4010 break;
4011 case G728:
4012 cmd = 0x5135;
4013 break;
4014 case G729:
4015 case G729B:
4016 cmd = 0x5136;
4017 break;
4018 default:
4019 return 1;
4020 }
4021 if (ixj_WriteDSPCommand(cmd, j))
4022 return -1;
4023 }
4024 if (!j->read_buffer) {
4025 if (!j->read_buffer)
4026 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
4027 if (!j->read_buffer) {
4028 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
4029 return -ENOMEM;
4030 }
4031 }
4032 j->read_buffer_size = j->rec_frame_size * 2;
4033
4034 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
4035
4036 return -1;
4037
4038 switch (j->rec_mode) {
4039 case 0:
4040 cmd = 0x1C03; /* Record C1 */
4041
4042 break;
4043 case 4:
4044 if (j->ver.low == 0x12) {
4045 cmd = 0x1E03; /* Record C1 */
4046
4047 } else {
4048 cmd = 0x1E01; /* Record C1 */
4049
4050 }
4051 break;
4052 case 5:
4053 if (j->ver.low == 0x12) {
4054 cmd = 0x1E83; /* Record C1 */
4055
4056 } else {
4057 cmd = 0x1E81; /* Record C1 */
4058
4059 }
4060 break;
4061 case 6:
4062 if (j->ver.low == 0x12) {
4063 cmd = 0x1F03; /* Record C1 */
4064
4065 } else {
4066 cmd = 0x1F01; /* Record C1 */
4067
4068 }
4069 break;
4070 case 7:
4071 if (j->ver.low == 0x12) {
4072 cmd = 0x1F83; /* Record C1 */
4073 } else {
4074 cmd = 0x1F81; /* Record C1 */
4075 }
4076 break;
4077 }
4078 if (ixj_WriteDSPCommand(cmd, j))
4079 return -1;
4080
4081 if (j->flags.playing) {
4082 ixj_aec_start(j, j->aec_level);
4083 }
4084 return 0;
4085 }
4086
4087 static void ixj_record_stop(IXJ *j)
4088 {
4089 if(ixjdebug & 0x0002)
4090 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
4091
4092 if (j->read_buffer) {
4093 kfree(j->read_buffer);
4094 j->read_buffer = NULL;
4095 j->read_buffer_size = 0;
4096 }
4097 if (j->rec_mode > -1) {
4098 ixj_WriteDSPCommand(0x5120, j);
4099 j->rec_mode = -1;
4100 }
4101 j->flags.recording = 0;
4102 }
4103 static void ixj_vad(IXJ *j, int arg)
4104 {
4105 if (arg)
4106 ixj_WriteDSPCommand(0x513F, j);
4107 else
4108 ixj_WriteDSPCommand(0x513E, j);
4109 }
4110
4111 static void set_rec_depth(IXJ *j, int depth)
4112 {
4113 if (depth > 60)
4114 depth = 60;
4115 if (depth < 0)
4116 depth = 0;
4117 ixj_WriteDSPCommand(0x5180 + depth, j);
4118 }
4119
4120 static void set_dtmf_prescale(IXJ *j, int volume)
4121 {
4122 ixj_WriteDSPCommand(0xCF07, j);
4123 ixj_WriteDSPCommand(volume, j);
4124 }
4125
4126 static int get_dtmf_prescale(IXJ *j)
4127 {
4128 ixj_WriteDSPCommand(0xCF05, j);
4129 return j->ssr.high << 8 | j->ssr.low;
4130 }
4131
4132 static void set_rec_volume(IXJ *j, int volume)
4133 {
4134 if(j->aec_level == AEC_AGC) {
4135 if (ixjdebug & 0x0002)
4136 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4137 ixj_WriteDSPCommand(0xCF96, j);
4138 ixj_WriteDSPCommand(volume, j);
4139 } else {
4140 if (ixjdebug & 0x0002)
4141 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4142 ixj_WriteDSPCommand(0xCF03, j);
4143 ixj_WriteDSPCommand(volume, j);
4144 }
4145 }
4146
4147 static int set_rec_volume_linear(IXJ *j, int volume)
4148 {
4149 int newvolume, dsprecmax;
4150
4151 if (ixjdebug & 0x0002)
4152 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4153 if(volume > 100 || volume < 0) {
4154 return -1;
4155 }
4156
4157 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4158 switch (j->cardtype) {
4159 case QTI_PHONEJACK:
4160 dsprecmax = 0x440;
4161 break;
4162 case QTI_LINEJACK:
4163 dsprecmax = 0x180;
4164 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4165 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4166 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4167 break;
4168 case QTI_PHONEJACK_LITE:
4169 dsprecmax = 0x4C0;
4170 break;
4171 case QTI_PHONEJACK_PCI:
4172 dsprecmax = 0x100;
4173 break;
4174 case QTI_PHONECARD:
4175 dsprecmax = 0x400;
4176 break;
4177 default:
4178 return -1;
4179 }
4180 newvolume = (dsprecmax * volume) / 100;
4181 set_rec_volume(j, newvolume);
4182 return 0;
4183 }
4184
4185 static int get_rec_volume(IXJ *j)
4186 {
4187 if(j->aec_level == AEC_AGC) {
4188 if (ixjdebug & 0x0002)
4189 printk(KERN_INFO "Getting AGC Threshold\n");
4190 ixj_WriteDSPCommand(0xCF86, j);
4191 if (ixjdebug & 0x0002)
4192 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4193 return j->ssr.high << 8 | j->ssr.low;
4194 } else {
4195 if (ixjdebug & 0x0002)
4196 printk(KERN_INFO "Getting Record Volume\n");
4197 ixj_WriteDSPCommand(0xCF01, j);
4198 return j->ssr.high << 8 | j->ssr.low;
4199 }
4200 }
4201
4202 static int get_rec_volume_linear(IXJ *j)
4203 {
4204 int volume, newvolume, dsprecmax;
4205
4206 switch (j->cardtype) {
4207 case QTI_PHONEJACK:
4208 dsprecmax = 0x440;
4209 break;
4210 case QTI_LINEJACK:
4211 dsprecmax = 0x180;
4212 break;
4213 case QTI_PHONEJACK_LITE:
4214 dsprecmax = 0x4C0;
4215 break;
4216 case QTI_PHONEJACK_PCI:
4217 dsprecmax = 0x100;
4218 break;
4219 case QTI_PHONECARD:
4220 dsprecmax = 0x400;
4221 break;
4222 default:
4223 return -1;
4224 }
4225 volume = get_rec_volume(j);
4226 newvolume = (volume * 100) / dsprecmax;
4227 if(newvolume > 100)
4228 newvolume = 100;
4229 return newvolume;
4230 }
4231
4232 static int get_rec_level(IXJ *j)
4233 {
4234 int retval;
4235
4236 ixj_WriteDSPCommand(0xCF88, j);
4237
4238 retval = j->ssr.high << 8 | j->ssr.low;
4239 retval = (retval * 256) / 240;
4240 return retval;
4241 }
4242
4243 static void ixj_aec_start(IXJ *j, int level)
4244 {
4245 j->aec_level = level;
4246 if (ixjdebug & 0x0002)
4247 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4248 if (!level) {
4249 aec_stop(j);
4250 } else {
4251 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4252 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4253
4254 ixj_WriteDSPCommand(0x0300, j);
4255 }
4256 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4257
4258 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4259
4260 switch (level) {
4261 case AEC_LOW:
4262 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4263
4264 ixj_WriteDSPCommand(0xE011, j);
4265 ixj_WriteDSPCommand(0xFFFF, j);
4266
4267 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4268 ixj_WriteDSPCommand(0x0000, j); /* to off */
4269
4270 break;
4271
4272 case AEC_MED:
4273 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4274
4275 ixj_WriteDSPCommand(0xE011, j);
4276 ixj_WriteDSPCommand(0x0080, j);
4277
4278 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4279 ixj_WriteDSPCommand(0x0000, j); /* to off */
4280
4281 break;
4282
4283 case AEC_HIGH:
4284 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4285
4286 ixj_WriteDSPCommand(0xE011, j);
4287 ixj_WriteDSPCommand(0x0080, j);
4288
4289 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4290 ixj_WriteDSPCommand(0x0000, j); /* to off */
4291
4292 break;
4293
4294 case AEC_AGC:
4295 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4296 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4297
4298 ixj_WriteDSPCommand(0xE011, j);
4299 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4300
4301 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4302
4303 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4304 ixj_WriteDSPCommand(0x0224, j);
4305 else
4306 ixj_WriteDSPCommand(0x1224, j);
4307
4308 ixj_WriteDSPCommand(0xE014, j);
4309 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4310
4311 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4312
4313 /* Now we can set the AGC initial parameters and turn it on */
4314 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4315 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4316
4317 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4318 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4319
4320 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4321 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4322
4323 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4324 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4325
4326 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4327 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4328
4329 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4330 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4331
4332 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4333 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4334
4335 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4336 ixj_WriteDSPCommand(0x0001, j); /* to on */
4337
4338 break;
4339
4340 case AEC_AUTO:
4341 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4342
4343 ixj_WriteDSPCommand(0xE011, j);
4344 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4345
4346 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4347
4348 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4349 ixj_WriteDSPCommand(0x0224, j);
4350 else
4351 ixj_WriteDSPCommand(0x1224, j);
4352
4353 ixj_WriteDSPCommand(0xE014, j);
4354 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4355
4356 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4357
4358 break;
4359 }
4360 }
4361 }
4362
4363 static void aec_stop(IXJ *j)
4364 {
4365 j->aec_level = AEC_OFF;
4366 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4367 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4368
4369 ixj_WriteDSPCommand(0x0700, j);
4370 }
4371 if (j->play_mode != -1 && j->rec_mode != -1)
4372 {
4373 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4374 }
4375 }
4376
4377 static int set_play_codec(IXJ *j, int rate)
4378 {
4379 int retval = 0;
4380
4381 j->play_codec = rate;
4382
4383 switch (rate) {
4384 case G723_63:
4385 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4386 j->play_frame_size = 12;
4387 j->play_mode = 0;
4388 } else {
4389 retval = 1;
4390 }
4391 break;
4392 case G723_53:
4393 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4394 j->play_frame_size = 10;
4395 j->play_mode = 0;
4396 } else {
4397 retval = 1;
4398 }
4399 break;
4400 case TS85:
4401 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4402 j->play_frame_size = 16;
4403 j->play_mode = 0;
4404 } else {
4405 retval = 1;
4406 }
4407 break;
4408 case TS48:
4409 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4410 j->play_frame_size = 9;
4411 j->play_mode = 0;
4412 } else {
4413 retval = 1;
4414 }
4415 break;
4416 case TS41:
4417 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4418 j->play_frame_size = 8;
4419 j->play_mode = 0;
4420 } else {
4421 retval = 1;
4422 }
4423 break;
4424 case G728:
4425 if (j->dsp.low != 0x20) {
4426 j->play_frame_size = 48;
4427 j->play_mode = 0;
4428 } else {
4429 retval = 1;
4430 }
4431 break;
4432 case G729:
4433 if (j->dsp.low != 0x20) {
4434 if (!j->flags.g729_loaded) {
4435 retval = 1;
4436 break;
4437 }
4438 switch (j->baseframe.low) {
4439 case 0xA0:
4440 j->play_frame_size = 10;
4441 break;
4442 case 0x50:
4443 j->play_frame_size = 5;
4444 break;
4445 default:
4446 j->play_frame_size = 15;
4447 break;
4448 }
4449 j->play_mode = 0;
4450 } else {
4451 retval = 1;
4452 }
4453 break;
4454 case G729B:
4455 if (j->dsp.low != 0x20) {
4456 if (!j->flags.g729_loaded) {
4457 retval = 1;
4458 break;
4459 }
4460 switch (j->baseframe.low) {
4461 case 0xA0:
4462 j->play_frame_size = 12;
4463 break;
4464 case 0x50:
4465 j->play_frame_size = 6;
4466 break;
4467 default:
4468 j->play_frame_size = 18;
4469 break;
4470 }
4471 j->play_mode = 0;
4472 } else {
4473 retval = 1;
4474 }
4475 break;
4476 case ULAW:
4477 switch (j->baseframe.low) {
4478 case 0xA0:
4479 j->play_frame_size = 80;
4480 break;
4481 case 0x50:
4482 j->play_frame_size = 40;
4483 break;
4484 default:
4485 j->play_frame_size = 120;
4486 break;
4487 }
4488 j->play_mode = 2;
4489 break;
4490 case ALAW:
4491 switch (j->baseframe.low) {
4492 case 0xA0:
4493 j->play_frame_size = 80;
4494 break;
4495 case 0x50:
4496 j->play_frame_size = 40;
4497 break;
4498 default:
4499 j->play_frame_size = 120;
4500 break;
4501 }
4502 j->play_mode = 2;
4503 break;
4504 case LINEAR16:
4505 switch (j->baseframe.low) {
4506 case 0xA0:
4507 j->play_frame_size = 160;
4508 break;
4509 case 0x50:
4510 j->play_frame_size = 80;
4511 break;
4512 default:
4513 j->play_frame_size = 240;
4514 break;
4515 }
4516 j->play_mode = 6;
4517 break;
4518 case LINEAR8:
4519 switch (j->baseframe.low) {
4520 case 0xA0:
4521 j->play_frame_size = 80;
4522 break;
4523 case 0x50:
4524 j->play_frame_size = 40;
4525 break;
4526 default:
4527 j->play_frame_size = 120;
4528 break;
4529 }
4530 j->play_mode = 4;
4531 break;
4532 case WSS:
4533 switch (j->baseframe.low) {
4534 case 0xA0:
4535 j->play_frame_size = 80;
4536 break;
4537 case 0x50:
4538 j->play_frame_size = 40;
4539 break;
4540 default:
4541 j->play_frame_size = 120;
4542 break;
4543 }
4544 j->play_mode = 5;
4545 break;
4546 default:
4547 j->play_frame_size = 0;
4548 j->play_mode = -1;
4549 if (j->write_buffer) {
4550 kfree(j->write_buffer);
4551 j->write_buffer = NULL;
4552 j->write_buffer_size = 0;
4553 }
4554 retval = 1;
4555 break;
4556 }
4557 return retval;
4558 }
4559
4560 static int ixj_play_start(IXJ *j)
4561 {
4562 unsigned short cmd = 0x0000;
4563
4564 if (j->write_buffer) {
4565 ixj_play_stop(j);
4566 }
4567
4568 if(ixjdebug & 0x0002)
4569 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4570
4571 j->flags.playing = 1;
4572 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4573
4574 j->flags.play_first_frame = 1;
4575 j->drybuffer = 0;
4576
4577 if (!j->play_mode) {
4578 switch (j->play_codec) {
4579 case G723_63:
4580 cmd = 0x5231;
4581 break;
4582 case G723_53:
4583 cmd = 0x5232;
4584 break;
4585 case TS85:
4586 cmd = 0x5230; /* TrueSpeech 8.5 */
4587
4588 break;
4589 case TS48:
4590 cmd = 0x5233; /* TrueSpeech 4.8 */
4591
4592 break;
4593 case TS41:
4594 cmd = 0x5234; /* TrueSpeech 4.1 */
4595
4596 break;
4597 case G728:
4598 cmd = 0x5235;
4599 break;
4600 case G729:
4601 case G729B:
4602 cmd = 0x5236;
4603 break;
4604 default:
4605 return 1;
4606 }
4607 if (ixj_WriteDSPCommand(cmd, j))
4608 return -1;
4609 }
4610 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4611 if (!j->write_buffer) {
4612 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4613 return -ENOMEM;
4614 }
4615 /* j->write_buffers_empty = 2; */
4616 j->write_buffers_empty = 1;
4617 j->write_buffer_size = j->play_frame_size * 2;
4618 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4619 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4620
4621 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4622
4623 return -1;
4624
4625 switch (j->play_mode) {
4626 case 0:
4627 cmd = 0x2C03;
4628 break;
4629 case 2:
4630 if (j->ver.low == 0x12) {
4631 cmd = 0x2C23;
4632 } else {
4633 cmd = 0x2C21;
4634 }
4635 break;
4636 case 4:
4637 if (j->ver.low == 0x12) {
4638 cmd = 0x2C43;
4639 } else {
4640 cmd = 0x2C41;
4641 }
4642 break;
4643 case 5:
4644 if (j->ver.low == 0x12) {
4645 cmd = 0x2C53;
4646 } else {
4647 cmd = 0x2C51;
4648 }
4649 break;
4650 case 6:
4651 if (j->ver.low == 0x12) {
4652 cmd = 0x2C63;
4653 } else {
4654 cmd = 0x2C61;
4655 }
4656 break;
4657 }
4658 if (ixj_WriteDSPCommand(cmd, j))
4659 return -1;
4660
4661 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4662 return -1;
4663
4664 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4665 return -1;
4666
4667 if (j->flags.recording) {
4668 ixj_aec_start(j, j->aec_level);
4669 }
4670
4671 return 0;
4672 }
4673
4674 static void ixj_play_stop(IXJ *j)
4675 {
4676 if(ixjdebug & 0x0002)
4677 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4678
4679 if (j->write_buffer) {
4680 kfree(j->write_buffer);
4681 j->write_buffer = NULL;
4682 j->write_buffer_size = 0;
4683 }
4684 if (j->play_mode > -1) {
4685 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4686
4687 j->play_mode = -1;
4688 }
4689 j->flags.playing = 0;
4690 }
4691
4692 static inline int get_play_level(IXJ *j)
4693 {
4694 int retval;
4695
4696 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4697 return j->ssr.high << 8 | j->ssr.low;
4698 retval = j->ssr.high << 8 | j->ssr.low;
4699 retval = (retval * 256) / 240;
4700 return retval;
4701 }
4702
4703 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4704 {
4705 unsigned int mask = 0;
4706
4707 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode->i_rdev));
4708
4709 poll_wait(file_p, &(j->poll_q), wait);
4710 if (j->read_buffer_ready > 0)
4711 mask |= POLLIN | POLLRDNORM; /* readable */
4712 if (j->write_buffers_empty > 0)
4713 mask |= POLLOUT | POLLWRNORM; /* writable */
4714 if (j->ex.bytes)
4715 mask |= POLLPRI;
4716 return mask;
4717 }
4718
4719 static int ixj_play_tone(IXJ *j, char tone)
4720 {
4721 if (!j->tone_state) {
4722 if(ixjdebug & 0x0002) {
4723 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4724 }
4725 if (j->dsp.low == 0x20) {
4726 idle(j);
4727 }
4728 j->tone_start_jif = jiffies;
4729
4730 j->tone_state = 1;
4731 }
4732
4733 j->tone_index = tone;
4734 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4735 return -1;
4736
4737 return 0;
4738 }
4739
4740 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4741 {
4742 j->tone_on_time = arg;
4743
4744 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4745
4746 return -1;
4747
4748 if (ixj_WriteDSPCommand(arg, j))
4749 return -1;
4750
4751 return 0;
4752 }
4753
4754 static int SCI_WaitHighSCI(IXJ *j)
4755 {
4756 int cnt;
4757
4758 j->pld_scrr.byte = inb_p(j->XILINXbase);
4759 if (!j->pld_scrr.bits.sci) {
4760 for (cnt = 0; cnt < 10; cnt++) {
4761 udelay(32);
4762 j->pld_scrr.byte = inb_p(j->XILINXbase);
4763
4764 if ((j->pld_scrr.bits.sci))
4765 return 1;
4766 }
4767 if (ixjdebug & 0x0001)
4768 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4769 return 0;
4770 } else
4771 return 1;
4772 }
4773
4774 static int SCI_WaitLowSCI(IXJ *j)
4775 {
4776 int cnt;
4777
4778 j->pld_scrr.byte = inb_p(j->XILINXbase);
4779 if (j->pld_scrr.bits.sci) {
4780 for (cnt = 0; cnt < 10; cnt++) {
4781 udelay(32);
4782 j->pld_scrr.byte = inb_p(j->XILINXbase);
4783
4784 if (!(j->pld_scrr.bits.sci))
4785 return 1;
4786 }
4787 if (ixjdebug & 0x0001)
4788 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4789 return 0;
4790 } else
4791 return 1;
4792 }
4793
4794 static int SCI_Control(IXJ *j, int control)
4795 {
4796 switch (control) {
4797 case SCI_End:
4798 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4799
4800 j->pld_scrw.bits.c1 = 0; /* to no selection */
4801
4802 break;
4803 case SCI_Enable_DAA:
4804 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4805
4806 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4807
4808 break;
4809 case SCI_Enable_Mixer:
4810 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4811
4812 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4813
4814 break;
4815 case SCI_Enable_EEPROM:
4816 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4817
4818 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4819
4820 break;
4821 default:
4822 return 0;
4823 break;
4824 }
4825 outb_p(j->pld_scrw.byte, j->XILINXbase);
4826
4827 switch (control) {
4828 case SCI_End:
4829 return 1;
4830 break;
4831 case SCI_Enable_DAA:
4832 case SCI_Enable_Mixer:
4833 case SCI_Enable_EEPROM:
4834 if (!SCI_WaitHighSCI(j))
4835 return 0;
4836 break;
4837 default:
4838 return 0;
4839 break;
4840 }
4841 return 1;
4842 }
4843
4844 static int SCI_Prepare(IXJ *j)
4845 {
4846 if (!SCI_Control(j, SCI_End))
4847 return 0;
4848
4849 if (!SCI_WaitLowSCI(j))
4850 return 0;
4851
4852 return 1;
4853 }
4854
4855 static int ixj_get_mixer(long val, IXJ *j)
4856 {
4857 int reg = (val & 0x1F00) >> 8;
4858 return j->mix.vol[reg];
4859 }
4860
4861 static int ixj_mixer(long val, IXJ *j)
4862 {
4863 BYTES bytes;
4864
4865 bytes.high = (val & 0x1F00) >> 8;
4866 bytes.low = val & 0x00FF;
4867
4868 /* save mixer value so we can get back later on */
4869 j->mix.vol[bytes.high] = bytes.low;
4870
4871 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4872
4873 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4874
4875 SCI_Control(j, SCI_Enable_Mixer);
4876
4877 SCI_Control(j, SCI_End);
4878
4879 return 0;
4880 }
4881
4882 static int daa_load(BYTES * p_bytes, IXJ *j)
4883 {
4884 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4885 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4886 if (!SCI_Control(j, SCI_Enable_DAA))
4887 return 0;
4888 else
4889 return 1;
4890 }
4891
4892 static int ixj_daa_cr4(IXJ *j, char reg)
4893 {
4894 BYTES bytes;
4895
4896 switch (j->daa_mode) {
4897 case SOP_PU_SLEEP:
4898 bytes.high = 0x14;
4899 break;
4900 case SOP_PU_RINGING:
4901 bytes.high = 0x54;
4902 break;
4903 case SOP_PU_CONVERSATION:
4904 bytes.high = 0x94;
4905 break;
4906 case SOP_PU_PULSEDIALING:
4907 bytes.high = 0xD4;
4908 break;
4909 }
4910
4911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4912
4913 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4914 case 0:
4915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4916 break;
4917 case 1:
4918 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4919 break;
4920 case 2:
4921 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4922 break;
4923 case 3:
4924 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4925 break;
4926 }
4927
4928 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4929
4930 if (!daa_load(&bytes, j))
4931 return 0;
4932
4933 if (!SCI_Prepare(j))
4934 return 0;
4935
4936 return 1;
4937 }
4938
4939 static char daa_int_read(IXJ *j)
4940 {
4941 BYTES bytes;
4942
4943 if (!SCI_Prepare(j))
4944 return 0;
4945
4946 bytes.high = 0x38;
4947 bytes.low = 0x00;
4948 outb_p(bytes.high, j->XILINXbase + 0x03);
4949 outb_p(bytes.low, j->XILINXbase + 0x02);
4950
4951 if (!SCI_Control(j, SCI_Enable_DAA))
4952 return 0;
4953
4954 bytes.high = inb_p(j->XILINXbase + 0x03);
4955 bytes.low = inb_p(j->XILINXbase + 0x02);
4956 if (bytes.low != ALISDAA_ID_BYTE) {
4957 if (ixjdebug & 0x0001)
4958 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4959 return 0;
4960 }
4961 if (!SCI_Control(j, SCI_Enable_DAA))
4962 return 0;
4963 if (!SCI_Control(j, SCI_End))
4964 return 0;
4965
4966 bytes.high = inb_p(j->XILINXbase + 0x03);
4967 bytes.low = inb_p(j->XILINXbase + 0x02);
4968
4969 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4970
4971 return 1;
4972 }
4973
4974 static char daa_CR_read(IXJ *j, int cr)
4975 {
4976 IXJ_WORD wdata;
4977 BYTES bytes;
4978
4979 if (!SCI_Prepare(j))
4980 return 0;
4981
4982 switch (j->daa_mode) {
4983 case SOP_PU_SLEEP:
4984 bytes.high = 0x30 + cr;
4985 break;
4986 case SOP_PU_RINGING:
4987 bytes.high = 0x70 + cr;
4988 break;
4989 case SOP_PU_CONVERSATION:
4990 bytes.high = 0xB0 + cr;
4991 break;
4992 case SOP_PU_PULSEDIALING:
4993 bytes.high = 0xF0 + cr;
4994 break;
4995 }
4996
4997 bytes.low = 0x00;
4998
4999 outb_p(bytes.high, j->XILINXbase + 0x03);
5000 outb_p(bytes.low, j->XILINXbase + 0x02);
5001
5002 if (!SCI_Control(j, SCI_Enable_DAA))
5003 return 0;
5004
5005 bytes.high = inb_p(j->XILINXbase + 0x03);
5006 bytes.low = inb_p(j->XILINXbase + 0x02);
5007 if (bytes.low != ALISDAA_ID_BYTE) {
5008 if (ixjdebug & 0x0001)
5009 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5010 return 0;
5011 }
5012 if (!SCI_Control(j, SCI_Enable_DAA))
5013 return 0;
5014 if (!SCI_Control(j, SCI_End))
5015 return 0;
5016
5017 wdata.word = inw_p(j->XILINXbase + 0x02);
5018
5019 switch(cr){
5020 case 5:
5021 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
5022 break;
5023 case 4:
5024 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
5025 break;
5026 case 3:
5027 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
5028 break;
5029 case 2:
5030 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
5031 break;
5032 case 1:
5033 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
5034 break;
5035 case 0:
5036 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
5037 break;
5038 default:
5039 return 0;
5040 }
5041 return 1;
5042 }
5043
5044 static int ixj_daa_cid_reset(IXJ *j)
5045 {
5046 int i;
5047 BYTES bytes;
5048
5049 if (ixjdebug & 0x0002)
5050 printk("DAA Clearing CID ram\n");
5051
5052 if (!SCI_Prepare(j))
5053 return 0;
5054
5055 bytes.high = 0x58;
5056 bytes.low = 0x00;
5057 outb_p(bytes.high, j->XILINXbase + 0x03);
5058 outb_p(bytes.low, j->XILINXbase + 0x02);
5059
5060 if (!SCI_Control(j, SCI_Enable_DAA))
5061 return 0;
5062
5063 if (!SCI_WaitHighSCI(j))
5064 return 0;
5065
5066 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
5067 bytes.high = bytes.low = 0x00;
5068 outb_p(bytes.high, j->XILINXbase + 0x03);
5069
5070 if (i < ALISDAA_CALLERID_SIZE - 1)
5071 outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073 if (!SCI_Control(j, SCI_Enable_DAA))
5074 return 0;
5075
5076 if (!SCI_WaitHighSCI(j))
5077 return 0;
5078
5079 }
5080
5081 if (!SCI_Control(j, SCI_End))
5082 return 0;
5083
5084 if (ixjdebug & 0x0002)
5085 printk("DAA CID ram cleared\n");
5086
5087 return 1;
5088 }
5089
5090 static int ixj_daa_cid_read(IXJ *j)
5091 {
5092 int i;
5093 BYTES bytes;
5094 char CID[ALISDAA_CALLERID_SIZE], mContinue;
5095 char *pIn, *pOut;
5096
5097 if (!SCI_Prepare(j))
5098 return 0;
5099
5100 bytes.high = 0x78;
5101 bytes.low = 0x00;
5102 outb_p(bytes.high, j->XILINXbase + 0x03);
5103 outb_p(bytes.low, j->XILINXbase + 0x02);
5104
5105 if (!SCI_Control(j, SCI_Enable_DAA))
5106 return 0;
5107
5108 if (!SCI_WaitHighSCI(j))
5109 return 0;
5110
5111 bytes.high = inb_p(j->XILINXbase + 0x03);
5112 bytes.low = inb_p(j->XILINXbase + 0x02);
5113 if (bytes.low != ALISDAA_ID_BYTE) {
5114 if (ixjdebug & 0x0001)
5115 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5116 return 0;
5117 }
5118 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5119 bytes.high = bytes.low = 0x00;
5120 outb_p(bytes.high, j->XILINXbase + 0x03);
5121 outb_p(bytes.low, j->XILINXbase + 0x02);
5122
5123 if (!SCI_Control(j, SCI_Enable_DAA))
5124 return 0;
5125
5126 if (!SCI_WaitHighSCI(j))
5127 return 0;
5128
5129 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5130 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5131 }
5132
5133 if (!SCI_Control(j, SCI_End))
5134 return 0;
5135
5136 pIn = CID;
5137 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5138 mContinue = 1;
5139 while (mContinue) {
5140 if ((pIn[1] & 0x03) == 0x01) {
5141 pOut[0] = pIn[0];
5142 }
5143 if ((pIn[2] & 0x0c) == 0x04) {
5144 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5145 }
5146 if ((pIn[3] & 0x30) == 0x10) {
5147 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5148 }
5149 if ((pIn[4] & 0xc0) == 0x40) {
5150 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5151 } else {
5152 mContinue = FALSE;
5153 }
5154 pIn += 5, pOut += 4;
5155 }
5156 memset(&j->cid, 0, sizeof(PHONE_CID));
5157 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5158 pOut += 4;
5159 strncpy(j->cid.month, pOut, 2);
5160 pOut += 2;
5161 strncpy(j->cid.day, pOut, 2);
5162 pOut += 2;
5163 strncpy(j->cid.hour, pOut, 2);
5164 pOut += 2;
5165 strncpy(j->cid.min, pOut, 2);
5166 pOut += 3;
5167 j->cid.numlen = *pOut;
5168 pOut += 1;
5169 strncpy(j->cid.number, pOut, j->cid.numlen);
5170 pOut += j->cid.numlen + 1;
5171 j->cid.namelen = *pOut;
5172 pOut += 1;
5173 strncpy(j->cid.name, pOut, j->cid.namelen);
5174
5175 ixj_daa_cid_reset(j);
5176 return 1;
5177 }
5178
5179 static char daa_get_version(IXJ *j)
5180 {
5181 BYTES bytes;
5182
5183 if (!SCI_Prepare(j))
5184 return 0;
5185
5186 bytes.high = 0x35;
5187 bytes.low = 0x00;
5188 outb_p(bytes.high, j->XILINXbase + 0x03);
5189 outb_p(bytes.low, j->XILINXbase + 0x02);
5190
5191 if (!SCI_Control(j, SCI_Enable_DAA))
5192 return 0;
5193
5194 bytes.high = inb_p(j->XILINXbase + 0x03);
5195 bytes.low = inb_p(j->XILINXbase + 0x02);
5196 if (bytes.low != ALISDAA_ID_BYTE) {
5197 if (ixjdebug & 0x0001)
5198 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5199 return 0;
5200 }
5201 if (!SCI_Control(j, SCI_Enable_DAA))
5202 return 0;
5203
5204 if (!SCI_Control(j, SCI_End))
5205 return 0;
5206
5207 bytes.high = inb_p(j->XILINXbase + 0x03);
5208 bytes.low = inb_p(j->XILINXbase + 0x02);
5209 if (ixjdebug & 0x0002)
5210 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5211 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5212 return bytes.high;
5213 }
5214
5215 static int daa_set_mode(IXJ *j, int mode)
5216 {
5217 /* NOTE:
5218 The DAA *MUST* be in the conversation mode if the
5219 PSTN line is to be seized (PSTN line off-hook).
5220 Taking the PSTN line off-hook while the DAA is in
5221 a mode other than conversation mode will cause a
5222 hardware failure of the ALIS-A part.
5223
5224 NOTE:
5225 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5226 if the PSTN line is on-hook. Failure to have the PSTN line
5227 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5228 ALIS-A part.
5229 */
5230
5231 BYTES bytes;
5232
5233 j->flags.pstn_rmr = 0;
5234
5235 if (!SCI_Prepare(j))
5236 return 0;
5237
5238 switch (mode) {
5239 case SOP_PU_RESET:
5240 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5241
5242 outb_p(j->pld_scrw.byte, j->XILINXbase);
5243 j->pld_slicw.bits.rly2 = 0;
5244 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5245 bytes.high = 0x10;
5246 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5247 daa_load(&bytes, j);
5248 if (!SCI_Prepare(j))
5249 return 0;
5250
5251 j->daa_mode = SOP_PU_SLEEP;
5252 break;
5253 case SOP_PU_SLEEP:
5254 if(j->daa_mode == SOP_PU_SLEEP)
5255 {
5256 break;
5257 }
5258 if (ixjdebug & 0x0008)
5259 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5260 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5261 {
5262 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5263
5264 outb_p(j->pld_scrw.byte, j->XILINXbase);
5265 j->pld_slicw.bits.rly2 = 0;
5266 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5267 bytes.high = 0x10;
5268 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5269 daa_load(&bytes, j);
5270 if (!SCI_Prepare(j))
5271 return 0;
5272 }
5273 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5274
5275 outb_p(j->pld_scrw.byte, j->XILINXbase);
5276 j->pld_slicw.bits.rly2 = 0;
5277 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5278 bytes.high = 0x10;
5279 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5280 daa_load(&bytes, j);
5281 if (!SCI_Prepare(j))
5282 return 0;
5283
5284 j->daa_mode = SOP_PU_SLEEP;
5285 j->flags.pstn_ringing = 0;
5286 j->ex.bits.pstn_ring = 0;
5287 j->pstn_sleeptil = jiffies + (hertz / 4);
5288 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5289 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5290 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5291 break;
5292 case SOP_PU_RINGING:
5293 if (ixjdebug & 0x0008)
5294 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5295 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5296
5297 outb_p(j->pld_scrw.byte, j->XILINXbase);
5298 j->pld_slicw.bits.rly2 = 0;
5299 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5300 bytes.high = 0x50;
5301 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5302 daa_load(&bytes, j);
5303 if (!SCI_Prepare(j))
5304 return 0;
5305 j->daa_mode = SOP_PU_RINGING;
5306 break;
5307 case SOP_PU_CONVERSATION:
5308 if (ixjdebug & 0x0008)
5309 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5310 bytes.high = 0x90;
5311 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5312 daa_load(&bytes, j);
5313 if (!SCI_Prepare(j))
5314 return 0;
5315 j->pld_slicw.bits.rly2 = 1;
5316 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5317 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5318
5319 outb_p(j->pld_scrw.byte, j->XILINXbase);
5320 j->daa_mode = SOP_PU_CONVERSATION;
5321 j->flags.pstn_ringing = 0;
5322 j->ex.bits.pstn_ring = 0;
5323 j->pstn_sleeptil = jiffies;
5324 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5325 break;
5326 case SOP_PU_PULSEDIALING:
5327 if (ixjdebug & 0x0008)
5328 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5329 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5330
5331 outb_p(j->pld_scrw.byte, j->XILINXbase);
5332 j->pld_slicw.bits.rly2 = 0;
5333 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5334 bytes.high = 0xD0;
5335 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5336 daa_load(&bytes, j);
5337 if (!SCI_Prepare(j))
5338 return 0;
5339 j->daa_mode = SOP_PU_PULSEDIALING;
5340 break;
5341 default:
5342 break;
5343 }
5344 return 1;
5345 }
5346
5347 static int ixj_daa_write(IXJ *j)
5348 {
5349 BYTES bytes;
5350
5351 j->flags.pstncheck = 1;
5352
5353 daa_set_mode(j, SOP_PU_SLEEP);
5354
5355 if (!SCI_Prepare(j))
5356 return 0;
5357
5358 outb_p(j->pld_scrw.byte, j->XILINXbase);
5359
5360 bytes.high = 0x14;
5361 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5362 if (!daa_load(&bytes, j))
5363 return 0;
5364
5365 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5366 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5367 if (!daa_load(&bytes, j))
5368 return 0;
5369
5370 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5371 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5372 if (!daa_load(&bytes, j))
5373 return 0;
5374
5375 if (!SCI_Prepare(j))
5376 return 0;
5377
5378 bytes.high = 0x1F;
5379 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5380 if (!daa_load(&bytes, j))
5381 return 0;
5382
5383 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5384 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5385 if (!daa_load(&bytes, j))
5386 return 0;
5387
5388 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5389 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5390 if (!daa_load(&bytes, j))
5391 return 0;
5392
5393 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5394 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5395 if (!daa_load(&bytes, j))
5396 return 0;
5397
5398 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5399 bytes.low = 0x00;
5400 if (!daa_load(&bytes, j))
5401 return 0;
5402
5403 if (!SCI_Prepare(j))
5404 return 0;
5405
5406 bytes.high = 0x00;
5407 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5408 if (!daa_load(&bytes, j))
5409 return 0;
5410
5411 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5412 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5413 if (!daa_load(&bytes, j))
5414 return 0;
5415
5416 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5417 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5418 if (!daa_load(&bytes, j))
5419 return 0;
5420
5421 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5422 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5423 if (!daa_load(&bytes, j))
5424 return 0;
5425
5426 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5427 bytes.low = 0x00;
5428 if (!daa_load(&bytes, j))
5429 return 0;
5430
5431 if (!SCI_Control(j, SCI_End))
5432 return 0;
5433 if (!SCI_WaitLowSCI(j))
5434 return 0;
5435
5436 bytes.high = 0x01;
5437 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5438 if (!daa_load(&bytes, j))
5439 return 0;
5440
5441 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5442 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5443 if (!daa_load(&bytes, j))
5444 return 0;
5445
5446 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5447 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5448 if (!daa_load(&bytes, j))
5449 return 0;
5450
5451 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5452 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5453 if (!daa_load(&bytes, j))
5454 return 0;
5455
5456 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5457 bytes.low = 0x00;
5458 if (!daa_load(&bytes, j))
5459 return 0;
5460
5461 if (!SCI_Control(j, SCI_End))
5462 return 0;
5463 if (!SCI_WaitLowSCI(j))
5464 return 0;
5465
5466 bytes.high = 0x02;
5467 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5468 if (!daa_load(&bytes, j))
5469 return 0;
5470
5471 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5472 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5473 if (!daa_load(&bytes, j))
5474 return 0;
5475
5476 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5477 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5478 if (!daa_load(&bytes, j))
5479 return 0;
5480
5481 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5482 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5483 if (!daa_load(&bytes, j))
5484 return 0;
5485
5486 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5487 bytes.low = 0x00;
5488 if (!daa_load(&bytes, j))
5489 return 0;
5490
5491 if (!SCI_Control(j, SCI_End))
5492 return 0;
5493 if (!SCI_WaitLowSCI(j))
5494 return 0;
5495
5496 bytes.high = 0x03;
5497 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5498 if (!daa_load(&bytes, j))
5499 return 0;
5500
5501 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5502 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5503 if (!daa_load(&bytes, j))
5504 return 0;
5505
5506 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5507 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5508 if (!daa_load(&bytes, j))
5509 return 0;
5510
5511 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5512 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5513 if (!daa_load(&bytes, j))
5514 return 0;
5515
5516 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5517 bytes.low = 0x00;
5518 if (!daa_load(&bytes, j))
5519 return 0;
5520
5521 if (!SCI_Control(j, SCI_End))
5522 return 0;
5523 if (!SCI_WaitLowSCI(j))
5524 return 0;
5525
5526 bytes.high = 0x04;
5527 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5528 if (!daa_load(&bytes, j))
5529 return 0;
5530
5531 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5532 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5533 if (!daa_load(&bytes, j))
5534 return 0;
5535
5536 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5537 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5538 if (!daa_load(&bytes, j))
5539 return 0;
5540
5541 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5542 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5543 if (!daa_load(&bytes, j))
5544 return 0;
5545
5546 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5547 bytes.low = 0x00;
5548 if (!daa_load(&bytes, j))
5549 return 0;
5550
5551 if (!SCI_Control(j, SCI_End))
5552 return 0;
5553 if (!SCI_WaitLowSCI(j))
5554 return 0;
5555
5556 bytes.high = 0x05;
5557 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5558 if (!daa_load(&bytes, j))
5559 return 0;
5560
5561 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5562 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5563 if (!daa_load(&bytes, j))
5564 return 0;
5565
5566 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5567 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5568 if (!daa_load(&bytes, j))
5569 return 0;
5570
5571 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5572 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5573 if (!daa_load(&bytes, j))
5574 return 0;
5575
5576 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5577 bytes.low = 0x00;
5578 if (!daa_load(&bytes, j))
5579 return 0;
5580
5581 if (!SCI_Control(j, SCI_End))
5582 return 0;
5583 if (!SCI_WaitLowSCI(j))
5584 return 0;
5585
5586 bytes.high = 0x06;
5587 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5588 if (!daa_load(&bytes, j))
5589 return 0;
5590
5591 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5592 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5593 if (!daa_load(&bytes, j))
5594 return 0;
5595
5596 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5597 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5598 if (!daa_load(&bytes, j))
5599 return 0;
5600
5601 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5602 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5603 if (!daa_load(&bytes, j))
5604 return 0;
5605
5606 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5607 bytes.low = 0x00;
5608 if (!daa_load(&bytes, j))
5609 return 0;
5610
5611 if (!SCI_Control(j, SCI_End))
5612 return 0;
5613 if (!SCI_WaitLowSCI(j))
5614 return 0;
5615
5616 bytes.high = 0x07;
5617 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5618 if (!daa_load(&bytes, j))
5619 return 0;
5620
5621 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5622 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5623 if (!daa_load(&bytes, j))
5624 return 0;
5625
5626 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5627 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5628 if (!daa_load(&bytes, j))
5629 return 0;
5630
5631 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5632 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5633 if (!daa_load(&bytes, j))
5634 return 0;
5635
5636 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5637 bytes.low = 0x00;
5638 if (!daa_load(&bytes, j))
5639 return 0;
5640
5641 if (!SCI_Control(j, SCI_End))
5642 return 0;
5643 if (!SCI_WaitLowSCI(j))
5644 return 0;
5645
5646 bytes.high = 0x08;
5647 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5648 if (!daa_load(&bytes, j))
5649 return 0;
5650
5651 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5652 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5653 if (!daa_load(&bytes, j))
5654 return 0;
5655
5656 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5657 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5658 if (!daa_load(&bytes, j))
5659 return 0;
5660
5661 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5662 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5663 if (!daa_load(&bytes, j))
5664 return 0;
5665
5666 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5667 bytes.low = 0x00;
5668 if (!daa_load(&bytes, j))
5669 return 0;
5670
5671 if (!SCI_Control(j, SCI_End))
5672 return 0;
5673 if (!SCI_WaitLowSCI(j))
5674 return 0;
5675
5676 bytes.high = 0x09;
5677 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5678 if (!daa_load(&bytes, j))
5679 return 0;
5680
5681 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5682 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5683 if (!daa_load(&bytes, j))
5684 return 0;
5685
5686 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5687 bytes.low = 0x00;
5688 if (!daa_load(&bytes, j))
5689 return 0;
5690
5691 if (!SCI_Control(j, SCI_End))
5692 return 0;
5693 if (!SCI_WaitLowSCI(j))
5694 return 0;
5695
5696 bytes.high = 0x0A;
5697 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5698 if (!daa_load(&bytes, j))
5699 return 0;
5700
5701 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5702 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5703 if (!daa_load(&bytes, j))
5704 return 0;
5705
5706 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5707 bytes.low = 0x00;
5708 if (!daa_load(&bytes, j))
5709 return 0;
5710
5711 if (!SCI_Control(j, SCI_End))
5712 return 0;
5713 if (!SCI_WaitLowSCI(j))
5714 return 0;
5715
5716 bytes.high = 0x0B;
5717 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5718 if (!daa_load(&bytes, j))
5719 return 0;
5720
5721 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5722 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5723 if (!daa_load(&bytes, j))
5724 return 0;
5725
5726 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5727 bytes.low = 0x00;
5728 if (!daa_load(&bytes, j))
5729 return 0;
5730
5731 if (!SCI_Control(j, SCI_End))
5732 return 0;
5733 if (!SCI_WaitLowSCI(j))
5734 return 0;
5735
5736 bytes.high = 0x0C;
5737 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5738 if (!daa_load(&bytes, j))
5739 return 0;
5740
5741 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5742 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5743 if (!daa_load(&bytes, j))
5744 return 0;
5745
5746 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5747 bytes.low = 0x00;
5748 if (!daa_load(&bytes, j))
5749 return 0;
5750
5751 if (!SCI_Control(j, SCI_End))
5752 return 0;
5753 if (!SCI_WaitLowSCI(j))
5754 return 0;
5755
5756 bytes.high = 0x0D;
5757 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5758 if (!daa_load(&bytes, j))
5759 return 0;
5760
5761 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5762 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5763 if (!daa_load(&bytes, j))
5764 return 0;
5765
5766 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5767 bytes.low = 0x00;
5768 if (!daa_load(&bytes, j))
5769 return 0;
5770
5771 if (!SCI_Control(j, SCI_End))
5772 return 0;
5773 if (!SCI_WaitLowSCI(j))
5774 return 0;
5775
5776 bytes.high = 0x0E;
5777 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5778 if (!daa_load(&bytes, j))
5779 return 0;
5780
5781 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5782 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5783 if (!daa_load(&bytes, j))
5784 return 0;
5785
5786 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5787 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5788 if (!daa_load(&bytes, j))
5789 return 0;
5790
5791 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5792 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5793 if (!daa_load(&bytes, j))
5794 return 0;
5795
5796 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5797 bytes.low = 0x00;
5798 if (!daa_load(&bytes, j))
5799 return 0;
5800
5801 if (!SCI_Control(j, SCI_End))
5802 return 0;
5803 if (!SCI_WaitLowSCI(j))
5804 return 0;
5805
5806 bytes.high = 0x0F;
5807 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5808 if (!daa_load(&bytes, j))
5809 return 0;
5810
5811 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5812 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5813 if (!daa_load(&bytes, j))
5814 return 0;
5815
5816 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5817 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5818 if (!daa_load(&bytes, j))
5819 return 0;
5820
5821 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5822 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5823 if (!daa_load(&bytes, j))
5824 return 0;
5825
5826 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5827 bytes.low = 0x00;
5828 if (!daa_load(&bytes, j))
5829 return 0;
5830
5831 udelay(32);
5832 j->pld_scrr.byte = inb_p(j->XILINXbase);
5833 if (!SCI_Control(j, SCI_End))
5834 return 0;
5835
5836 outb_p(j->pld_scrw.byte, j->XILINXbase);
5837
5838 if (ixjdebug & 0x0002)
5839 printk("DAA Coefficients Loaded\n");
5840
5841 j->flags.pstncheck = 0;
5842 return 1;
5843 }
5844
5845 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5846 {
5847 j->tone_off_time = arg;
5848 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5849
5850 return -1;
5851 if (ixj_WriteDSPCommand(arg, j))
5852 return -1;
5853 return 0;
5854 }
5855
5856 static int ixj_get_tone_on(IXJ *j)
5857 {
5858 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5859
5860 return -1;
5861 return 0;
5862 }
5863
5864 static int ixj_get_tone_off(IXJ *j)
5865 {
5866 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5867
5868 return -1;
5869 return 0;
5870 }
5871
5872 static void ixj_busytone(IXJ *j)
5873 {
5874 j->flags.ringback = 0;
5875 j->flags.dialtone = 0;
5876 j->flags.busytone = 1;
5877 ixj_set_tone_on(0x07D0, j);
5878 ixj_set_tone_off(0x07D0, j);
5879 ixj_play_tone(j, 27);
5880 }
5881
5882 static void ixj_dialtone(IXJ *j)
5883 {
5884 j->flags.ringback = 0;
5885 j->flags.dialtone = 1;
5886 j->flags.busytone = 0;
5887 if (j->dsp.low == 0x20) {
5888 return;
5889 } else {
5890 ixj_set_tone_on(0xFFFF, j);
5891 ixj_set_tone_off(0x0000, j);
5892 ixj_play_tone(j, 25);
5893 }
5894 }
5895
5896 static void ixj_cpt_stop(IXJ *j)
5897 {
5898 if(j->tone_state || j->tone_cadence_state)
5899 {
5900 j->flags.dialtone = 0;
5901 j->flags.busytone = 0;
5902 j->flags.ringback = 0;
5903 ixj_set_tone_on(0x0001, j);
5904 ixj_set_tone_off(0x0000, j);
5905 ixj_play_tone(j, 0);
5906 j->tone_state = j->tone_cadence_state = 0;
5907 if (j->cadence_t) {
5908 if (j->cadence_t->ce) {
5909 kfree(j->cadence_t->ce);
5910 }
5911 kfree(j->cadence_t);
5912 j->cadence_t = NULL;
5913 }
5914 }
5915 if (j->play_mode == -1 && j->rec_mode == -1)
5916 idle(j);
5917 if (j->play_mode != -1 && j->dsp.low == 0x20)
5918 ixj_play_start(j);
5919 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5920 ixj_record_start(j);
5921 }
5922
5923 static void ixj_ringback(IXJ *j)
5924 {
5925 j->flags.busytone = 0;
5926 j->flags.dialtone = 0;
5927 j->flags.ringback = 1;
5928 ixj_set_tone_on(0x0FA0, j);
5929 ixj_set_tone_off(0x2EE0, j);
5930 ixj_play_tone(j, 26);
5931 }
5932
5933 static void ixj_testram(IXJ *j)
5934 {
5935 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5936 }
5937
5938 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE * cp)
5939 {
5940 IXJ_CADENCE *lcp;
5941 IXJ_CADENCE_ELEMENT *lcep;
5942 IXJ_TONE ti;
5943
5944 lcp = kmalloc(sizeof(IXJ_CADENCE), GFP_KERNEL);
5945 if (lcp == NULL)
5946 return -ENOMEM;
5947 if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_CADENCE)) || (unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE) )
5948 {
5949 kfree(lcp);
5950 return -EFAULT;
5951 }
5952 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5953 if (lcep == NULL) {
5954 kfree(lcp);
5955 return -ENOMEM;
5956 }
5957 if (copy_from_user(lcep, lcp->ce, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5958 {
5959 kfree(lcep);
5960 kfree(lcp);
5961 return -EFAULT;
5962 }
5963 if (j->cadence_t) {
5964 kfree(j->cadence_t->ce);
5965 kfree(j->cadence_t);
5966 }
5967 lcp->ce = (void *) lcep;
5968 j->cadence_t = lcp;
5969 j->tone_cadence_state = 0;
5970 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5971 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5972 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5973 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5974 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5975 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5976 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5977 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5978 ixj_init_tone(j, &ti);
5979 }
5980 ixj_play_tone(j, lcp->ce[0].index);
5981 return 1;
5982 }
5983
5984 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE * cp)
5985 {
5986 IXJ_FILTER_CADENCE *lcp;
5987 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5988 if (lcp == NULL) {
5989 if(ixjdebug & 0x0001) {
5990 printk(KERN_INFO "Could not allocate memory for cadence\n");
5991 }
5992 return -ENOMEM;
5993 }
5994 if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_FILTER_CADENCE))) {
5995 if(ixjdebug & 0x0001) {
5996 printk(KERN_INFO "Could not copy cadence to kernel\n");
5997 }
5998 return -EFAULT;
5999 }
6000 if (lcp->filter > 5) {
6001 if(ixjdebug & 0x0001) {
6002 printk(KERN_INFO "Cadence out of range\n");
6003 }
6004 return -1;
6005 }
6006 j->cadence_f[lcp->filter].state = 0;
6007 j->cadence_f[lcp->filter].enable = lcp->enable;
6008 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
6009 j->cadence_f[lcp->filter].on1 = lcp->on1;
6010 j->cadence_f[lcp->filter].on1min = 0;
6011 j->cadence_f[lcp->filter].on1max = 0;
6012 j->cadence_f[lcp->filter].off1 = lcp->off1;
6013 j->cadence_f[lcp->filter].off1min = 0;
6014 j->cadence_f[lcp->filter].off1max = 0;
6015 j->cadence_f[lcp->filter].on2 = lcp->on2;
6016 j->cadence_f[lcp->filter].on2min = 0;
6017 j->cadence_f[lcp->filter].on2max = 0;
6018 j->cadence_f[lcp->filter].off2 = lcp->off2;
6019 j->cadence_f[lcp->filter].off2min = 0;
6020 j->cadence_f[lcp->filter].off2max = 0;
6021 j->cadence_f[lcp->filter].on3 = lcp->on3;
6022 j->cadence_f[lcp->filter].on3min = 0;
6023 j->cadence_f[lcp->filter].on3max = 0;
6024 j->cadence_f[lcp->filter].off3 = lcp->off3;
6025 j->cadence_f[lcp->filter].off3min = 0;
6026 j->cadence_f[lcp->filter].off3max = 0;
6027 kfree(lcp);
6028 if(ixjdebug & 0x0002) {
6029 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
6030 }
6031 return 0;
6032 }
6033
6034 static void add_caps(IXJ *j)
6035 {
6036 j->caps = 0;
6037 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
6038 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
6039 j->caplist[j->caps].captype = vendor;
6040 j->caplist[j->caps].handle = j->caps++;
6041 j->caplist[j->caps].captype = device;
6042 switch (j->cardtype) {
6043 case QTI_PHONEJACK:
6044 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
6045 break;
6046 case QTI_LINEJACK:
6047 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
6048 break;
6049 case QTI_PHONEJACK_LITE:
6050 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
6051 break;
6052 case QTI_PHONEJACK_PCI:
6053 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
6054 break;
6055 case QTI_PHONECARD:
6056 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
6057 break;
6058 }
6059 j->caplist[j->caps].cap = j->cardtype;
6060 j->caplist[j->caps].handle = j->caps++;
6061 strcpy(j->caplist[j->caps].desc, "POTS");
6062 j->caplist[j->caps].captype = port;
6063 j->caplist[j->caps].cap = pots;
6064 j->caplist[j->caps].handle = j->caps++;
6065
6066 /* add devices that can do speaker/mic */
6067 switch (j->cardtype) {
6068 case QTI_PHONEJACK:
6069 case QTI_LINEJACK:
6070 case QTI_PHONEJACK_PCI:
6071 case QTI_PHONECARD:
6072 strcpy(j->caplist[j->caps].desc, "SPEAKER");
6073 j->caplist[j->caps].captype = port;
6074 j->caplist[j->caps].cap = speaker;
6075 j->caplist[j->caps].handle = j->caps++;
6076 default:
6077 break;
6078 }
6079
6080 /* add devices that can do handset */
6081 switch (j->cardtype) {
6082 case QTI_PHONEJACK:
6083 strcpy(j->caplist[j->caps].desc, "HANDSET");
6084 j->caplist[j->caps].captype = port;
6085 j->caplist[j->caps].cap = handset;
6086 j->caplist[j->caps].handle = j->caps++;
6087 break;
6088 default:
6089 break;
6090 }
6091
6092 /* add devices that can do PSTN */
6093 switch (j->cardtype) {
6094 case QTI_LINEJACK:
6095 strcpy(j->caplist[j->caps].desc, "PSTN");
6096 j->caplist[j->caps].captype = port;
6097 j->caplist[j->caps].cap = pstn;
6098 j->caplist[j->caps].handle = j->caps++;
6099 break;
6100 default:
6101 break;
6102 }
6103
6104 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6105 strcpy(j->caplist[j->caps].desc, "ULAW");
6106 j->caplist[j->caps].captype = codec;
6107 j->caplist[j->caps].cap = ULAW;
6108 j->caplist[j->caps].handle = j->caps++;
6109
6110 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6111 j->caplist[j->caps].captype = codec;
6112 j->caplist[j->caps].cap = LINEAR16;
6113 j->caplist[j->caps].handle = j->caps++;
6114
6115 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6116 j->caplist[j->caps].captype = codec;
6117 j->caplist[j->caps].cap = LINEAR8;
6118 j->caplist[j->caps].handle = j->caps++;
6119
6120 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6121 j->caplist[j->caps].captype = codec;
6122 j->caplist[j->caps].cap = WSS;
6123 j->caplist[j->caps].handle = j->caps++;
6124
6125 /* software ALAW codec, made from ULAW */
6126 strcpy(j->caplist[j->caps].desc, "ALAW");
6127 j->caplist[j->caps].captype = codec;
6128 j->caplist[j->caps].cap = ALAW;
6129 j->caplist[j->caps].handle = j->caps++;
6130
6131 /* version 12 of the 8020 does the following codecs in a broken way */
6132 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6133 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6134 j->caplist[j->caps].captype = codec;
6135 j->caplist[j->caps].cap = G723_63;
6136 j->caplist[j->caps].handle = j->caps++;
6137
6138 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6139 j->caplist[j->caps].captype = codec;
6140 j->caplist[j->caps].cap = G723_53;
6141 j->caplist[j->caps].handle = j->caps++;
6142
6143 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6144 j->caplist[j->caps].captype = codec;
6145 j->caplist[j->caps].cap = TS48;
6146 j->caplist[j->caps].handle = j->caps++;
6147
6148 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6149 j->caplist[j->caps].captype = codec;
6150 j->caplist[j->caps].cap = TS41;
6151 j->caplist[j->caps].handle = j->caps++;
6152 }
6153
6154 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6155 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6156 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6157 j->caplist[j->caps].captype = codec;
6158 j->caplist[j->caps].cap = TS85;
6159 j->caplist[j->caps].handle = j->caps++;
6160 }
6161
6162 /* 8021 chips can do G728 */
6163 if (j->dsp.low == 0x21) {
6164 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6165 j->caplist[j->caps].captype = codec;
6166 j->caplist[j->caps].cap = G728;
6167 j->caplist[j->caps].handle = j->caps++;
6168 }
6169
6170 /* 8021/8022 chips can do G729 if loaded */
6171 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6172 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6173 j->caplist[j->caps].captype = codec;
6174 j->caplist[j->caps].cap = G729;
6175 j->caplist[j->caps].handle = j->caps++;
6176 }
6177 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6178 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6179 j->caplist[j->caps].captype = codec;
6180 j->caplist[j->caps].cap = G729B;
6181 j->caplist[j->caps].handle = j->caps++;
6182 }
6183 }
6184
6185 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6186 {
6187 int cnt;
6188 int retval = 0;
6189 for (cnt = 0; cnt < j->caps; cnt++) {
6190 if (pcreq->captype == j->caplist[cnt].captype
6191 && pcreq->cap == j->caplist[cnt].cap) {
6192 retval = 1;
6193 break;
6194 }
6195 }
6196 return retval;
6197 }
6198
6199 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6200 {
6201 IXJ_TONE ti;
6202 IXJ_FILTER jf;
6203 IXJ_FILTER_RAW jfr;
6204
6205 unsigned int raise, mant;
6206 unsigned int minor = MINOR(inode->i_rdev);
6207 int board = NUM(inode->i_rdev);
6208
6209 IXJ *j = get_ixj(NUM(inode->i_rdev));
6210
6211 int retval = 0;
6212
6213 /*
6214 * Set up locks to ensure that only one process is talking to the DSP at a time.
6215 * This is necessary to keep the DSP from locking up.
6216 */
6217 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6218 set_current_state(TASK_INTERRUPTIBLE);
6219 schedule_timeout(1);
6220 }
6221 if (ixjdebug & 0x0040)
6222 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6223 if (minor >= IXJMAX) {
6224 clear_bit(board, &j->busyflags);
6225 return -ENODEV;
6226 }
6227 /*
6228 * Check ioctls only root can use.
6229 */
6230 if (!capable(CAP_SYS_ADMIN)) {
6231 switch (cmd) {
6232 case IXJCTL_TESTRAM:
6233 case IXJCTL_HZ:
6234 retval = -EPERM;
6235 }
6236 }
6237 switch (cmd) {
6238 case IXJCTL_TESTRAM:
6239 ixj_testram(j);
6240 retval = (j->ssr.high << 8) + j->ssr.low;
6241 break;
6242 case IXJCTL_CARDTYPE:
6243 retval = j->cardtype;
6244 break;
6245 case IXJCTL_SERIAL:
6246 retval = j->serial;
6247 break;
6248 case IXJCTL_VERSION:
6249 if (copy_to_user((char *) arg, ixj_c_revision, strlen(ixj_c_revision)))
6250 retval = -EFAULT;
6251 break;
6252 case PHONE_RING_CADENCE:
6253 j->ring_cadence = arg;
6254 break;
6255 case IXJCTL_CIDCW:
6256 if(arg) {
6257 copy_from_user(&j->cid_send, (char *)arg, sizeof(PHONE_CID));
6258 }
6259 else {
6260 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6261 }
6262 ixj_write_cidcw(j);
6263 break;
6264 /* Binary compatbility */
6265 case OLD_PHONE_RING_START:
6266 arg = 0;
6267 /* Fall through */
6268 case PHONE_RING_START:
6269 if(arg) {
6270 if(copy_from_user(&j->cid_send, (char *)arg, sizeof(PHONE_CID)))
6271 {
6272 retval = -EFAULT;
6273 break;
6274 }
6275 ixj_write_cid(j);
6276 }
6277 else {
6278 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6279 }
6280 ixj_ring_start(j);
6281 break;
6282 case PHONE_RING_STOP:
6283 j->flags.cringing = 0;
6284 if(j->cadence_f[5].enable) {
6285 j->cadence_f[5].state = 0;
6286 }
6287 ixj_ring_off(j);
6288 break;
6289 case PHONE_RING:
6290 retval = ixj_ring(j);
6291 break;
6292 case PHONE_EXCEPTION:
6293 retval = j->ex.bytes;
6294 if(j->ex.bits.flash) {
6295 j->flash_end = 0;
6296 j->ex.bits.flash = 0;
6297 }
6298 j->ex.bits.pstn_ring = 0;
6299 j->ex.bits.caller_id = 0;
6300 j->ex.bits.pstn_wink = 0;
6301 j->ex.bits.f0 = 0;
6302 j->ex.bits.f1 = 0;
6303 j->ex.bits.f2 = 0;
6304 j->ex.bits.f3 = 0;
6305 j->ex.bits.fc0 = 0;
6306 j->ex.bits.fc1 = 0;
6307 j->ex.bits.fc2 = 0;
6308 j->ex.bits.fc3 = 0;
6309 j->ex.bits.reserved = 0;
6310 break;
6311 case PHONE_HOOKSTATE:
6312 j->ex.bits.hookstate = 0;
6313 retval = j->hookstate; //j->r_hook;
6314 break;
6315 case IXJCTL_SET_LED:
6316 LED_SetState(arg, j);
6317 break;
6318 case PHONE_FRAME:
6319 retval = set_base_frame(j, arg);
6320 break;
6321 case PHONE_REC_CODEC:
6322 retval = set_rec_codec(j, arg);
6323 break;
6324 case PHONE_VAD:
6325 ixj_vad(j, arg);
6326 break;
6327 case PHONE_REC_START:
6328 ixj_record_start(j);
6329 break;
6330 case PHONE_REC_STOP:
6331 ixj_record_stop(j);
6332 break;
6333 case PHONE_REC_DEPTH:
6334 set_rec_depth(j, arg);
6335 break;
6336 case PHONE_REC_VOLUME:
6337 if(arg == -1) {
6338 retval = get_rec_volume(j);
6339 }
6340 else {
6341 set_rec_volume(j, arg);
6342 retval = arg;
6343 }
6344 break;
6345 case PHONE_REC_VOLUME_LINEAR:
6346 if(arg == -1) {
6347 retval = get_rec_volume_linear(j);
6348 }
6349 else {
6350 set_rec_volume_linear(j, arg);
6351 retval = arg;
6352 }
6353 break;
6354 case IXJCTL_DTMF_PRESCALE:
6355 if(arg == -1) {
6356 retval = get_dtmf_prescale(j);
6357 }
6358 else {
6359 set_dtmf_prescale(j, arg);
6360 retval = arg;
6361 }
6362 break;
6363 case PHONE_REC_LEVEL:
6364 retval = get_rec_level(j);
6365 break;
6366 case IXJCTL_SC_RXG:
6367 retval = ixj_siadc(j, arg);
6368 break;
6369 case IXJCTL_SC_TXG:
6370 retval = ixj_sidac(j, arg);
6371 break;
6372 case IXJCTL_AEC_START:
6373 ixj_aec_start(j, arg);
6374 break;
6375 case IXJCTL_AEC_STOP:
6376 aec_stop(j);
6377 break;
6378 case IXJCTL_AEC_GET_LEVEL:
6379 retval = j->aec_level;
6380 break;
6381 case PHONE_PLAY_CODEC:
6382 retval = set_play_codec(j, arg);
6383 break;
6384 case PHONE_PLAY_START:
6385 retval = ixj_play_start(j);
6386 break;
6387 case PHONE_PLAY_STOP:
6388 ixj_play_stop(j);
6389 break;
6390 case PHONE_PLAY_DEPTH:
6391 set_play_depth(j, arg);
6392 break;
6393 case PHONE_PLAY_VOLUME:
6394 if(arg == -1) {
6395 retval = get_play_volume(j);
6396 }
6397 else {
6398 set_play_volume(j, arg);
6399 retval = arg;
6400 }
6401 break;
6402 case PHONE_PLAY_VOLUME_LINEAR:
6403 if(arg == -1) {
6404 retval = get_play_volume_linear(j);
6405 }
6406 else {
6407 set_play_volume_linear(j, arg);
6408 retval = arg;
6409 }
6410 break;
6411 case PHONE_PLAY_LEVEL:
6412 retval = get_play_level(j);
6413 break;
6414 case IXJCTL_DSP_TYPE:
6415 retval = (j->dsp.high << 8) + j->dsp.low;
6416 break;
6417 case IXJCTL_DSP_VERSION:
6418 retval = (j->ver.high << 8) + j->ver.low;
6419 break;
6420 case IXJCTL_HZ:
6421 hertz = arg;
6422 break;
6423 case IXJCTL_RATE:
6424 if (arg > hertz)
6425 retval = -1;
6426 else
6427 samplerate = arg;
6428 break;
6429 case IXJCTL_DRYBUFFER_READ:
6430 put_user(j->drybuffer, (unsigned long *) arg);
6431 break;
6432 case IXJCTL_DRYBUFFER_CLEAR:
6433 j->drybuffer = 0;
6434 break;
6435 case IXJCTL_FRAMES_READ:
6436 put_user(j->framesread, (unsigned long *) arg);
6437 break;
6438 case IXJCTL_FRAMES_WRITTEN:
6439 put_user(j->frameswritten, (unsigned long *) arg);
6440 break;
6441 case IXJCTL_READ_WAIT:
6442 put_user(j->read_wait, (unsigned long *) arg);
6443 break;
6444 case IXJCTL_WRITE_WAIT:
6445 put_user(j->write_wait, (unsigned long *) arg);
6446 break;
6447 case PHONE_MAXRINGS:
6448 j->maxrings = arg;
6449 break;
6450 case PHONE_SET_TONE_ON_TIME:
6451 ixj_set_tone_on(arg, j);
6452 break;
6453 case PHONE_SET_TONE_OFF_TIME:
6454 ixj_set_tone_off(arg, j);
6455 break;
6456 case PHONE_GET_TONE_ON_TIME:
6457 if (ixj_get_tone_on(j)) {
6458 retval = -1;
6459 } else {
6460 retval = (j->ssr.high << 8) + j->ssr.low;
6461 }
6462 break;
6463 case PHONE_GET_TONE_OFF_TIME:
6464 if (ixj_get_tone_off(j)) {
6465 retval = -1;
6466 } else {
6467 retval = (j->ssr.high << 8) + j->ssr.low;
6468 }
6469 break;
6470 case PHONE_PLAY_TONE:
6471 if (!j->tone_state)
6472 retval = ixj_play_tone(j, arg);
6473 else
6474 retval = -1;
6475 break;
6476 case PHONE_GET_TONE_STATE:
6477 retval = j->tone_state;
6478 break;
6479 case PHONE_DTMF_READY:
6480 retval = j->ex.bits.dtmf_ready;
6481 break;
6482 case PHONE_GET_DTMF:
6483 if (ixj_hookstate(j)) {
6484 if (j->dtmf_rp != j->dtmf_wp) {
6485 retval = j->dtmfbuffer[j->dtmf_rp];
6486 j->dtmf_rp++;
6487 if (j->dtmf_rp == 79)
6488 j->dtmf_rp = 0;
6489 if (j->dtmf_rp == j->dtmf_wp) {
6490 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6491 }
6492 }
6493 }
6494 break;
6495 case PHONE_GET_DTMF_ASCII:
6496 if (ixj_hookstate(j)) {
6497 if (j->dtmf_rp != j->dtmf_wp) {
6498 switch (j->dtmfbuffer[j->dtmf_rp]) {
6499 case 10:
6500 retval = 42; /* '*'; */
6501
6502 break;
6503 case 11:
6504 retval = 48; /*'0'; */
6505
6506 break;
6507 case 12:
6508 retval = 35; /*'#'; */
6509
6510 break;
6511 case 28:
6512 retval = 65; /*'A'; */
6513
6514 break;
6515 case 29:
6516 retval = 66; /*'B'; */
6517
6518 break;
6519 case 30:
6520 retval = 67; /*'C'; */
6521
6522 break;
6523 case 31:
6524 retval = 68; /*'D'; */
6525
6526 break;
6527 default:
6528 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6529 break;
6530 }
6531 j->dtmf_rp++;
6532 if (j->dtmf_rp == 79)
6533 j->dtmf_rp = 0;
6534 if(j->dtmf_rp == j->dtmf_wp)
6535 {
6536 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6537 }
6538 }
6539 }
6540 break;
6541 case PHONE_DTMF_OOB:
6542 j->flags.dtmf_oob = arg;
6543 break;
6544 case PHONE_DIALTONE:
6545 ixj_dialtone(j);
6546 break;
6547 case PHONE_BUSY:
6548 ixj_busytone(j);
6549 break;
6550 case PHONE_RINGBACK:
6551 ixj_ringback(j);
6552 break;
6553 case PHONE_WINK:
6554 if(j->cardtype == QTI_PHONEJACK)
6555 retval = -1;
6556 else
6557 retval = ixj_wink(j);
6558 break;
6559 case PHONE_CPT_STOP:
6560 ixj_cpt_stop(j);
6561 break;
6562 case PHONE_QUERY_CODEC:
6563 {
6564 struct phone_codec_data pd;
6565 int val;
6566 int proto_size[] = {
6567 -1,
6568 12, 10, 16, 9, 8, 48, 5,
6569 40, 40, 80, 40, 40, 6
6570 };
6571 if(copy_from_user(&pd, (void *)arg, sizeof(pd))) {
6572 retval = -EFAULT;
6573 break;
6574 }
6575 if(pd.type<1 || pd.type>13) {
6576 retval = -EPROTONOSUPPORT;
6577 break;
6578 }
6579 if(pd.type<G729)
6580 val=proto_size[pd.type];
6581 else switch(j->baseframe.low)
6582 {
6583 case 0xA0:val=2*proto_size[pd.type];break;
6584 case 0x50:val=proto_size[pd.type];break;
6585 default:val=proto_size[pd.type]*3;break;
6586 }
6587 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6588 if(copy_to_user((void *)arg, &pd, sizeof(pd)))
6589 retval = -EFAULT;
6590 break;
6591 }
6592 case IXJCTL_DSP_IDLE:
6593 idle(j);
6594 break;
6595 case IXJCTL_MIXER:
6596 if ((arg & 0xff) == 0xff)
6597 retval = ixj_get_mixer(arg, j);
6598 else
6599 ixj_mixer(arg, j);
6600 break;
6601 case IXJCTL_DAA_COEFF_SET:
6602 switch (arg) {
6603 case DAA_US:
6604 DAA_Coeff_US(j);
6605 retval = ixj_daa_write(j);
6606 break;
6607 case DAA_UK:
6608 DAA_Coeff_UK(j);
6609 retval = ixj_daa_write(j);
6610 break;
6611 case DAA_FRANCE:
6612 DAA_Coeff_France(j);
6613 retval = ixj_daa_write(j);
6614 break;
6615 case DAA_GERMANY:
6616 DAA_Coeff_Germany(j);
6617 retval = ixj_daa_write(j);
6618 break;
6619 case DAA_AUSTRALIA:
6620 DAA_Coeff_Australia(j);
6621 retval = ixj_daa_write(j);
6622 break;
6623 case DAA_JAPAN:
6624 DAA_Coeff_Japan(j);
6625 retval = ixj_daa_write(j);
6626 break;
6627 default:
6628 retval = 1;
6629 break;
6630 }
6631 break;
6632 case IXJCTL_DAA_AGAIN:
6633 ixj_daa_cr4(j, arg | 0x02);
6634 break;
6635 case IXJCTL_PSTN_LINETEST:
6636 retval = ixj_linetest(j);
6637 break;
6638 case IXJCTL_VMWI:
6639 ixj_write_vmwi(j, arg);
6640 break;
6641 case IXJCTL_CID:
6642 if (copy_to_user((char *) arg, &j->cid, sizeof(PHONE_CID)))
6643 retval = -EFAULT;
6644 j->ex.bits.caller_id = 0;
6645 break;
6646 case IXJCTL_WINK_DURATION:
6647 j->winktime = arg;
6648 break;
6649 case IXJCTL_PORT:
6650 if (arg)
6651 retval = ixj_set_port(j, arg);
6652 else
6653 retval = j->port;
6654 break;
6655 case IXJCTL_POTS_PSTN:
6656 retval = ixj_set_pots(j, arg);
6657 break;
6658 case PHONE_CAPABILITIES:
6659 add_caps(j);
6660 retval = j->caps;
6661 break;
6662 case PHONE_CAPABILITIES_LIST:
6663 add_caps(j);
6664 if (copy_to_user((char *) arg, j->caplist, sizeof(struct phone_capability) * j->caps))
6665 retval = -EFAULT;
6666 break;
6667 case PHONE_CAPABILITIES_CHECK:
6668 {
6669 struct phone_capability cap;
6670 if (copy_from_user(&cap, (char *) arg, sizeof(cap)))
6671 retval = -EFAULT;
6672 else {
6673 add_caps(j);
6674 retval = capabilities_check(j, &cap);
6675 }
6676 }
6677 break;
6678 case PHONE_PSTN_SET_STATE:
6679 daa_set_mode(j, arg);
6680 break;
6681 case PHONE_PSTN_GET_STATE:
6682 retval = j->daa_mode;
6683 j->ex.bits.pstn_ring = 0;
6684 break;
6685 case IXJCTL_SET_FILTER:
6686 if (copy_from_user(&jf, (char *) arg, sizeof(jf)))
6687 retval = -EFAULT;
6688 retval = ixj_init_filter(j, &jf);
6689 break;
6690 case IXJCTL_SET_FILTER_RAW:
6691 if (copy_from_user(&jfr, (char *) arg, sizeof(jfr)))
6692 retval = -EFAULT;
6693 retval = ixj_init_filter_raw(j, &jfr);
6694 break;
6695 case IXJCTL_GET_FILTER_HIST:
6696 if(arg<0||arg>3)
6697 retval = -EINVAL;
6698 else
6699 retval = j->filter_hist[arg];
6700 break;
6701 case IXJCTL_INIT_TONE:
6702 copy_from_user(&ti, (char *) arg, sizeof(ti));
6703 retval = ixj_init_tone(j, &ti);
6704 break;
6705 case IXJCTL_TONE_CADENCE:
6706 retval = ixj_build_cadence(j, (IXJ_CADENCE *) arg);
6707 break;
6708 case IXJCTL_FILTER_CADENCE:
6709 retval = ixj_build_filter_cadence(j, (IXJ_FILTER_CADENCE *) arg);
6710 break;
6711 case IXJCTL_SIGCTL:
6712 if (copy_from_user(&j->sigdef, (char *)arg, sizeof(IXJ_SIGDEF)))
6713 retval = -EFAULT;
6714 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6715 if(j->sigdef.event < 33) {
6716 raise = 1;
6717 for(mant = 0; mant < j->sigdef.event; mant++){
6718 raise *= 2;
6719 }
6720 if(j->sigdef.signal)
6721 j->ex_sig.bytes |= raise;
6722 else
6723 j->ex_sig.bytes &= (raise^0xffff);
6724 }
6725 break;
6726 case IXJCTL_INTERCOM_STOP:
6727 if(arg < 0 || arg >= IXJMAX)
6728 return -EINVAL;
6729 j->intercom = -1;
6730 ixj_record_stop(j);
6731 ixj_play_stop(j);
6732 idle(j);
6733 get_ixj(arg)->intercom = -1;
6734 ixj_record_stop(get_ixj(arg));
6735 ixj_play_stop(get_ixj(arg));
6736 idle(get_ixj(arg));
6737 break;
6738 case IXJCTL_INTERCOM_START:
6739 if(arg < 0 || arg >= IXJMAX)
6740 return -EINVAL;
6741 j->intercom = arg;
6742 ixj_record_start(j);
6743 ixj_play_start(j);
6744 get_ixj(arg)->intercom = board;
6745 ixj_play_start(get_ixj(arg));
6746 ixj_record_start(get_ixj(arg));
6747 break;
6748 }
6749 if (ixjdebug & 0x0040)
6750 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6751 clear_bit(board, &j->busyflags);
6752 return retval;
6753 }
6754
6755 static int ixj_fasync(int fd, struct file *file_p, int mode)
6756 {
6757 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode->i_rdev));
6758
6759 return fasync_helper(fd, file_p, mode, &j->async_queue);
6760 }
6761
6762 struct file_operations ixj_fops =
6763 {
6764 owner: THIS_MODULE,
6765 read: ixj_enhanced_read,
6766 write: ixj_enhanced_write,
6767 poll: ixj_poll,
6768 ioctl: ixj_ioctl,
6769 release: ixj_release,
6770 fasync: ixj_fasync
6771 };
6772
6773 static int ixj_linetest(IXJ *j)
6774 {
6775 unsigned long jifwait;
6776
6777 j->flags.pstncheck = 1; /* Testing */
6778 j->flags.pstn_present = 0; /* Assume the line is not there */
6779
6780 daa_int_read(j); /*Clear DAA Interrupt flags */
6781 /* */
6782 /* Hold all relays in the normally de-energized position. */
6783 /* */
6784
6785 j->pld_slicw.bits.rly1 = 0;
6786 j->pld_slicw.bits.rly2 = 0;
6787 j->pld_slicw.bits.rly3 = 0;
6788 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6789 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6790
6791 outb_p(j->pld_scrw.byte, j->XILINXbase);
6792 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6793 if (j->pld_slicr.bits.potspstn) {
6794 j->flags.pots_pstn = 1;
6795 j->flags.pots_correct = 0;
6796 LED_SetState(0x4, j);
6797 } else {
6798 j->flags.pots_pstn = 0;
6799 j->pld_slicw.bits.rly1 = 0;
6800 j->pld_slicw.bits.rly2 = 0;
6801 j->pld_slicw.bits.rly3 = 1;
6802 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6803 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6804
6805 outb_p(j->pld_scrw.byte, j->XILINXbase);
6806 daa_set_mode(j, SOP_PU_CONVERSATION);
6807 jifwait = jiffies + hertz;
6808 while (time_before(jiffies, jifwait)) {
6809 set_current_state(TASK_INTERRUPTIBLE);
6810 schedule_timeout(1);
6811 }
6812 daa_int_read(j);
6813 daa_set_mode(j, SOP_PU_RESET);
6814 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6815 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6816 LED_SetState(0x4, j);
6817 j->pld_slicw.bits.rly3 = 0;
6818 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6819 } else {
6820 j->flags.pots_correct = 1;
6821 LED_SetState(0x8, j);
6822 j->pld_slicw.bits.rly1 = 1;
6823 j->pld_slicw.bits.rly2 = 0;
6824 j->pld_slicw.bits.rly3 = 0;
6825 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6826 }
6827 }
6828 j->pld_slicw.bits.rly3 = 0;
6829 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6830 daa_set_mode(j, SOP_PU_CONVERSATION);
6831 jifwait = jiffies + hertz;
6832 while (time_before(jiffies, jifwait)) {
6833 set_current_state(TASK_INTERRUPTIBLE);
6834 schedule_timeout(1);
6835 }
6836 daa_int_read(j);
6837 daa_set_mode(j, SOP_PU_RESET);
6838 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6839 j->pstn_sleeptil = jiffies + (hertz / 4);
6840 j->flags.pstn_present = 1;
6841 } else {
6842 j->flags.pstn_present = 0;
6843 }
6844 if (j->flags.pstn_present) {
6845 if (j->flags.pots_correct) {
6846 LED_SetState(0xA, j);
6847 } else {
6848 LED_SetState(0x6, j);
6849 }
6850 } else {
6851 if (j->flags.pots_correct) {
6852 LED_SetState(0x9, j);
6853 } else {
6854 LED_SetState(0x5, j);
6855 }
6856 }
6857 j->flags.pstncheck = 0; /* Testing */
6858 return j->flags.pstn_present;
6859 }
6860
6861 static int ixj_selfprobe(IXJ *j)
6862 {
6863 unsigned short cmd;
6864 unsigned long jif;
6865 int cnt;
6866 BYTES bytes;
6867
6868 init_waitqueue_head(&j->poll_q);
6869 init_waitqueue_head(&j->read_q);
6870 init_waitqueue_head(&j->write_q);
6871
6872 while(atomic_read(&j->DSPWrite) > 0)
6873 atomic_dec(&j->DSPWrite);
6874 if (ixjdebug & 0x0002)
6875 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6876 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6877
6878 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6879 return -1;
6880 /* The read values of the SSR should be 0x00 for the IDLE command */
6881 if (j->ssr.low || j->ssr.high)
6882 return -1;
6883 if (ixjdebug & 0x0002)
6884 printk(KERN_INFO "Get Device ID Code\n");
6885 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6886 return -1;
6887 j->dsp.low = j->ssr.low;
6888 j->dsp.high = j->ssr.high;
6889 if (ixjdebug & 0x0002)
6890 printk(KERN_INFO "Get Device Version Code\n");
6891 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6892 return -1;
6893 j->ver.low = j->ssr.low;
6894 j->ver.high = j->ssr.high;
6895 if (!j->cardtype) {
6896 if (j->dsp.low == 0x21) {
6897 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6898 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6899 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6900 bytes.low = inb_p(j->XILINXbase + 0x02);
6901 if (bytes.low == bytes.high) /* Register is read only on */
6902 /* Internet PhoneJack Lite */
6903 {
6904 j->cardtype = QTI_PHONEJACK_LITE;
6905 if (check_region(j->XILINXbase, 4)) {
6906 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6907 return -1;
6908 }
6909 request_region(j->XILINXbase, 4, "ixj control");
6910 j->pld_slicw.pcib.e1 = 1;
6911 outb_p(j->pld_slicw.byte, j->XILINXbase);
6912 } else {
6913 j->cardtype = QTI_LINEJACK;
6914
6915 if (check_region(j->XILINXbase, 8)) {
6916 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6917 return -1;
6918 }
6919 request_region(j->XILINXbase, 8, "ixj control");
6920 }
6921 } else if (j->dsp.low == 0x22) {
6922 j->cardtype = QTI_PHONEJACK_PCI;
6923 request_region(j->XILINXbase, 4, "ixj control");
6924 j->pld_slicw.pcib.e1 = 1;
6925 outb_p(j->pld_slicw.byte, j->XILINXbase);
6926 } else
6927 j->cardtype = QTI_PHONEJACK;
6928 } else {
6929 switch (j->cardtype) {
6930 case QTI_PHONEJACK:
6931 if (!j->dsp.low != 0x20) {
6932 j->dsp.high = 0x80;
6933 j->dsp.low = 0x20;
6934 ixj_WriteDSPCommand(0x3800, j);
6935 j->ver.low = j->ssr.low;
6936 j->ver.high = j->ssr.high;
6937 }
6938 break;
6939 case QTI_LINEJACK:
6940 if (check_region(j->XILINXbase, 8)) {
6941 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6942 return -1;
6943 }
6944 request_region(j->XILINXbase, 8, "ixj control");
6945 break;
6946 case QTI_PHONEJACK_LITE:
6947 case QTI_PHONEJACK_PCI:
6948 if (check_region(j->XILINXbase, 4)) {
6949 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6950 return -1;
6951 }
6952 request_region(j->XILINXbase, 4, "ixj control");
6953 j->pld_slicw.pcib.e1 = 1;
6954 outb_p(j->pld_slicw.byte, j->XILINXbase);
6955 break;
6956 case QTI_PHONECARD:
6957 break;
6958 }
6959 }
6960 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6961 if (ixjdebug & 0x0002)
6962 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6963 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6964 return -1;
6965 if (ixjdebug & 0x0002)
6966 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6967 if (j->cardtype == QTI_PHONEJACK) {
6968 cmd = 0x9FF2;
6969 } else {
6970 cmd = 0x9FF5;
6971 }
6972 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6973 return -1;
6974 } else {
6975 if (set_base_frame(j, 30) != 30)
6976 return -1;
6977 if (ixjdebug & 0x0002)
6978 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6979 if (j->cardtype == QTI_PHONECARD) {
6980 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6981 return -1;
6982 }
6983 if (j->cardtype == QTI_LINEJACK) {
6984 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6985 return -1;
6986 if (ixjdebug & 0x0002)
6987 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6988 j->pld_clock.byte = 0;
6989 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6990 }
6991 }
6992
6993 if (j->dsp.low == 0x20) {
6994 if (ixjdebug & 0x0002)
6995 printk(KERN_INFO "Configure GPIO pins\n");
6996 j->gpio.bytes.high = 0x09;
6997 /* bytes.low = 0xEF; 0xF7 */
6998 j->gpio.bits.gpio1 = 1;
6999 j->gpio.bits.gpio2 = 1;
7000 j->gpio.bits.gpio3 = 0;
7001 j->gpio.bits.gpio4 = 1;
7002 j->gpio.bits.gpio5 = 1;
7003 j->gpio.bits.gpio6 = 1;
7004 j->gpio.bits.gpio7 = 1;
7005 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
7006 if (ixjdebug & 0x0002)
7007 printk(KERN_INFO "Enable SLIC\n");
7008 j->gpio.bytes.high = 0x0B;
7009 j->gpio.bytes.low = 0x00;
7010 j->gpio.bits.gpio1 = 0;
7011 j->gpio.bits.gpio2 = 1;
7012 j->gpio.bits.gpio5 = 0;
7013 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
7014 j->port = PORT_POTS;
7015 } else {
7016 if (j->cardtype == QTI_LINEJACK) {
7017 LED_SetState(0x1, j);
7018 jif = jiffies + (hertz / 10);
7019 while (time_before(jiffies, jif)) {
7020 set_current_state(TASK_INTERRUPTIBLE);
7021 schedule_timeout(1);
7022 }
7023 LED_SetState(0x2, j);
7024 jif = jiffies + (hertz / 10);
7025 while (time_before(jiffies, jif)) {
7026 set_current_state(TASK_INTERRUPTIBLE);
7027 schedule_timeout(1);
7028 }
7029 LED_SetState(0x4, j);
7030 jif = jiffies + (hertz / 10);
7031 while (time_before(jiffies, jif)) {
7032 set_current_state(TASK_INTERRUPTIBLE);
7033 schedule_timeout(1);
7034 }
7035 LED_SetState(0x8, j);
7036 jif = jiffies + (hertz / 10);
7037 while (time_before(jiffies, jif)) {
7038 set_current_state(TASK_INTERRUPTIBLE);
7039 schedule_timeout(1);
7040 }
7041 LED_SetState(0x0, j);
7042 daa_get_version(j);
7043 if (ixjdebug & 0x0002)
7044 printk("Loading DAA Coefficients\n");
7045 DAA_Coeff_US(j);
7046 if (!ixj_daa_write(j)) {
7047 printk("DAA write failed on board %d\n", j->board);
7048 return -1;
7049 }
7050 if(!ixj_daa_cid_reset(j)) {
7051 printk("DAA CID reset failed on board %d\n", j->board);
7052 return -1;
7053 }
7054 j->flags.pots_correct = 0;
7055 j->flags.pstn_present = 0;
7056 ixj_linetest(j);
7057 if (j->flags.pots_correct) {
7058 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7059
7060 outb_p(j->pld_scrw.byte, j->XILINXbase);
7061 j->pld_slicw.bits.rly1 = 1;
7062 j->pld_slicw.bits.spken = 1;
7063 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7064 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7065 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7066 j->port = PORT_POTS;
7067 }
7068 ixj_set_port(j, PORT_PSTN);
7069 ixj_set_pots(j, 1);
7070 if (ixjdebug & 0x0002)
7071 printk(KERN_INFO "Enable Mixer\n");
7072 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
7073 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
7074
7075 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
7076 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
7077
7078 ixj_mixer(0x0480, j); /*FM Left mute */
7079 ixj_mixer(0x0580, j); /*FM Right mute */
7080
7081 ixj_mixer(0x0680, j); /*CD Left mute */
7082 ixj_mixer(0x0780, j); /*CD Right mute */
7083
7084 ixj_mixer(0x0880, j); /*Line Left mute */
7085 ixj_mixer(0x0980, j); /*Line Right mute */
7086
7087 ixj_mixer(0x0A80, j); /*Aux left mute */
7088 ixj_mixer(0x0B80, j); /*Aux right mute */
7089
7090 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
7091 ixj_mixer(0x0D80, j); /*Mono2 mute */
7092
7093 ixj_mixer(0x0E80, j); /*Mic mute */
7094
7095 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
7096
7097 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
7098 ixj_mixer(0x110C, j);
7099
7100
7101 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
7102 ixj_mixer(0x1401, j);
7103
7104 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
7105 ixj_mixer(0x1501, j);
7106
7107 ixj_mixer(0x1700, j); /*Clock select */
7108
7109 ixj_mixer(0x1800, j); /*ADC input from mixer */
7110
7111 ixj_mixer(0x1901, j); /*Mic gain 30db */
7112
7113 if (ixjdebug & 0x0002)
7114 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7115 j->cadence_f[4].state = 0;
7116 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7117 j->cadence_f[4].off1 = 0;
7118 j->cadence_f[4].on2 = 0;
7119 j->cadence_f[4].off2 = 0;
7120 j->cadence_f[4].on3 = 0;
7121 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7122 j->pstn_last_rmr = jiffies;
7123
7124 } else {
7125 if (j->cardtype == QTI_PHONECARD) {
7126 ixj_WriteDSPCommand(0xCF07, j);
7127 ixj_WriteDSPCommand(0x00B0, j);
7128 ixj_set_port(j, PORT_SPEAKER);
7129 } else {
7130 ixj_set_port(j, PORT_POTS);
7131 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7132 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7133 }
7134 }
7135 }
7136
7137 j->intercom = -1;
7138 j->framesread = j->frameswritten = 0;
7139 j->read_wait = j->write_wait = 0;
7140 j->rxreadycheck = j->txreadycheck = 0;
7141
7142 /* initialise the DTMF prescale to a sensible value */
7143 if (j->cardtype == QTI_LINEJACK) {
7144 set_dtmf_prescale(j, 0x10);
7145 } else {
7146 set_dtmf_prescale(j, 0x40);
7147 }
7148 set_play_volume(j, 0x100);
7149 set_rec_volume(j, 0x100);
7150
7151 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7152 return -1;
7153 /* The read values of the SSR should be 0x00 for the IDLE command */
7154 if (j->ssr.low || j->ssr.high)
7155 return -1;
7156
7157 if (ixjdebug & 0x0002)
7158 printk(KERN_INFO "Enable Line Monitor\n");
7159
7160 if (ixjdebug & 0x0002)
7161 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7162
7163 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7164 return -1;
7165
7166 if (ixjdebug & 0x002)
7167 printk(KERN_INFO "Enable DTMF Detectors\n");
7168
7169 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7170 return -1;
7171
7172 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7173 return -1;
7174
7175 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7176
7177 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7178
7179 j->ex.bits.dtmf_ready = 0;
7180 j->dtmf_state = 0;
7181 j->dtmf_wp = j->dtmf_rp = 0;
7182 j->rec_mode = j->play_mode = -1;
7183 j->flags.ringing = 0;
7184 j->maxrings = MAXRINGS;
7185 j->ring_cadence = USA_RING_CADENCE;
7186 j->drybuffer = 0;
7187 j->winktime = 320;
7188 j->flags.dtmf_oob = 0;
7189 for (cnt = 0; cnt < 4; cnt++)
7190 j->cadence_f[cnt].enable = 0;
7191 /* must be a device on the specified address */
7192 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7193
7194 /* Set up the default signals for events */
7195 for (cnt = 0; cnt < 35; cnt++)
7196 j->ixj_signals[cnt] = SIGIO;
7197
7198 /* Set the excetion signal enable flags */
7199 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7200 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 =
7201 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;
7202 #ifdef IXJ_DYN_ALLOC
7203 j->fskdata = NULL;
7204 #endif
7205 j->fskdcnt = 0;
7206 j->cidcw_wait = 0;
7207
7208 /* Register with the Telephony for Linux subsystem */
7209 j->p.f_op = &ixj_fops;
7210 j->p.open = ixj_open;
7211 j->p.board = j->board;
7212 phone_register_device(&j->p, PHONE_UNIT_ANY);
7213
7214 ixj_init_timer(j);
7215 ixj_add_timer(j);
7216 return 0;
7217 }
7218
7219 /*
7220 * Exported service for pcmcia card handling
7221 */
7222
7223 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7224 {
7225 IXJ *j = ixj_alloc();
7226
7227 j->board = 0;
7228
7229 j->DSPbase = dsp;
7230 j->XILINXbase = xilinx;
7231 j->cardtype = QTI_PHONECARD;
7232 ixj_selfprobe(j);
7233 return j;
7234 }
7235
7236 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7237
7238 static int ixj_get_status_proc(char *buf)
7239 {
7240 int len;
7241 int cnt;
7242 IXJ *j;
7243 len = 0;
7244 len += sprintf(buf + len, "%s", ixj_c_rcsid);
7245 len += sprintf(buf + len, "\n%s", ixj_h_rcsid);
7246 len += sprintf(buf + len, "\n%s", ixjuser_h_rcsid);
7247 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7248 len += sprintf(buf + len, "\nsizeof IXJ struct %d bytes", sizeof(IXJ));
7249 len += sprintf(buf + len, "\nsizeof DAA struct %d bytes", sizeof(DAA_REGS));
7250 len += sprintf(buf + len, "\nUsing old telephony API");
7251 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7252
7253 for (cnt = 0; cnt < IXJMAX; cnt++) {
7254 j = get_ixj(cnt);
7255 if(j==NULL)
7256 continue;
7257 if (j->DSPbase) {
7258 len += sprintf(buf + len, "\nCard Num %d", cnt);
7259 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7260 if (j->cardtype != QTI_PHONEJACK)
7261 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7262 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7263 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7264 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7265 switch (j->cardtype) {
7266 case (QTI_PHONEJACK):
7267 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7268 break;
7269 case (QTI_LINEJACK):
7270 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7271 if (j->flags.g729_loaded)
7272 len += sprintf(buf + len, " w/G.729 A/B");
7273 len += sprintf(buf + len, " Country = %d", j->daa_country);
7274 break;
7275 case (QTI_PHONEJACK_LITE):
7276 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7277 if (j->flags.g729_loaded)
7278 len += sprintf(buf + len, " w/G.729 A/B");
7279 break;
7280 case (QTI_PHONEJACK_PCI):
7281 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7282 if (j->flags.g729_loaded)
7283 len += sprintf(buf + len, " w/G.729 A/B");
7284 break;
7285 case (QTI_PHONECARD):
7286 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7287 if (j->flags.g729_loaded)
7288 len += sprintf(buf + len, " w/G.729 A/B");
7289 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7290 if (!j->pccr1.bits.drf)
7291 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7292 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7293 break;
7294 default:
7295 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7296 break;
7297 }
7298 len += sprintf(buf + len, "\nReaders %d", j->readers);
7299 len += sprintf(buf + len, "\nWriters %d", j->writers);
7300 add_caps(j);
7301 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7302 if (j->dsp.low != 0x20)
7303 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7304 if (j->flags.cidsent)
7305 len += sprintf(buf + len, "\nCaller ID data sent");
7306 else
7307 len += sprintf(buf + len, "\nCaller ID data not sent");
7308
7309 len += sprintf(buf + len, "\nPlay CODEC ");
7310 switch (j->play_codec) {
7311 case G723_63:
7312 len += sprintf(buf + len, "G.723.1 6.3");
7313 break;
7314 case G723_53:
7315 len += sprintf(buf + len, "G.723.1 5.3");
7316 break;
7317 case TS85:
7318 len += sprintf(buf + len, "TrueSpeech 8.5");
7319 break;
7320 case TS48:
7321 len += sprintf(buf + len, "TrueSpeech 4.8");
7322 break;
7323 case TS41:
7324 len += sprintf(buf + len, "TrueSpeech 4.1");
7325 break;
7326 case G728:
7327 len += sprintf(buf + len, "G.728");
7328 break;
7329 case G729:
7330 len += sprintf(buf + len, "G.729");
7331 break;
7332 case G729B:
7333 len += sprintf(buf + len, "G.729B");
7334 break;
7335 case ULAW:
7336 len += sprintf(buf + len, "uLaw");
7337 break;
7338 case ALAW:
7339 len += sprintf(buf + len, "aLaw");
7340 break;
7341 case LINEAR16:
7342 len += sprintf(buf + len, "16 bit Linear");
7343 break;
7344 case LINEAR8:
7345 len += sprintf(buf + len, "8 bit Linear");
7346 break;
7347 case WSS:
7348 len += sprintf(buf + len, "Windows Sound System");
7349 break;
7350 default:
7351 len += sprintf(buf + len, "NO CODEC CHOSEN");
7352 break;
7353 }
7354 len += sprintf(buf + len, "\nRecord CODEC ");
7355 switch (j->rec_codec) {
7356 case G723_63:
7357 len += sprintf(buf + len, "G.723.1 6.3");
7358 break;
7359 case G723_53:
7360 len += sprintf(buf + len, "G.723.1 5.3");
7361 break;
7362 case TS85:
7363 len += sprintf(buf + len, "TrueSpeech 8.5");
7364 break;
7365 case TS48:
7366 len += sprintf(buf + len, "TrueSpeech 4.8");
7367 break;
7368 case TS41:
7369 len += sprintf(buf + len, "TrueSpeech 4.1");
7370 break;
7371 case G728:
7372 len += sprintf(buf + len, "G.728");
7373 break;
7374 case G729:
7375 len += sprintf(buf + len, "G.729");
7376 break;
7377 case G729B:
7378 len += sprintf(buf + len, "G.729B");
7379 break;
7380 case ULAW:
7381 len += sprintf(buf + len, "uLaw");
7382 break;
7383 case ALAW:
7384 len += sprintf(buf + len, "aLaw");
7385 break;
7386 case LINEAR16:
7387 len += sprintf(buf + len, "16 bit Linear");
7388 break;
7389 case LINEAR8:
7390 len += sprintf(buf + len, "8 bit Linear");
7391 break;
7392 case WSS:
7393 len += sprintf(buf + len, "Windows Sound System");
7394 break;
7395 default:
7396 len += sprintf(buf + len, "NO CODEC CHOSEN");
7397 break;
7398 }
7399 len += sprintf(buf + len, "\nAEC ");
7400 switch (j->aec_level) {
7401 case AEC_OFF:
7402 len += sprintf(buf + len, "Off");
7403 break;
7404 case AEC_LOW:
7405 len += sprintf(buf + len, "Low");
7406 break;
7407 case AEC_MED:
7408 len += sprintf(buf + len, "Med");
7409 break;
7410 case AEC_HIGH:
7411 len += sprintf(buf + len, "High");
7412 break;
7413 case AEC_AUTO:
7414 len += sprintf(buf + len, "Auto");
7415 break;
7416 case AEC_AGC:
7417 len += sprintf(buf + len, "AEC/AGC");
7418 break;
7419 default:
7420 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7421 break;
7422 }
7423
7424 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7425 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7426 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7427
7428 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7429
7430 if (j->cardtype == QTI_LINEJACK) {
7431 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7432 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7433 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7434 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7435 switch (j->daa_mode) {
7436 case SOP_PU_SLEEP:
7437 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7438 break;
7439 case SOP_PU_RINGING:
7440 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7441 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7442 break;
7443 case SOP_PU_CONVERSATION:
7444 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7445 break;
7446 case SOP_PU_PULSEDIALING:
7447 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7448 break;
7449 }
7450 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7451 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7452 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7453 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7454 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7455 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7456 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7457 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7458 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7459 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7460 }
7461 switch (j->port) {
7462 case PORT_POTS:
7463 len += sprintf(buf + len, "\nPort POTS");
7464 break;
7465 case PORT_PSTN:
7466 len += sprintf(buf + len, "\nPort PSTN");
7467 break;
7468 case PORT_SPEAKER:
7469 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7470 break;
7471 case PORT_HANDSET:
7472 len += sprintf(buf + len, "\nPort HANDSET");
7473 break;
7474 }
7475 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7476 len += sprintf(buf + len, "\nSLIC state ");
7477 switch (SLIC_GetState(j)) {
7478 case PLD_SLIC_STATE_OC:
7479 len += sprintf(buf + len, "OC");
7480 break;
7481 case PLD_SLIC_STATE_RINGING:
7482 len += sprintf(buf + len, "RINGING");
7483 break;
7484 case PLD_SLIC_STATE_ACTIVE:
7485 len += sprintf(buf + len, "ACTIVE");
7486 break;
7487 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7488 len += sprintf(buf + len, "OHT");
7489 break;
7490 case PLD_SLIC_STATE_TIPOPEN:
7491 len += sprintf(buf + len, "TIPOPEN");
7492 break;
7493 case PLD_SLIC_STATE_STANDBY:
7494 len += sprintf(buf + len, "STANDBY");
7495 break;
7496 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7497 len += sprintf(buf + len, "APR");
7498 break;
7499 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7500 len += sprintf(buf + len, "OHTPR");
7501 break;
7502 default:
7503 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7504 break;
7505 }
7506 }
7507 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7508 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7509 #ifdef PERFMON_STATS
7510 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7511 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7512 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7513 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7514 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7515 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7516 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7517 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7518 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7519 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7520 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7521 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7522 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7523 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7524
7525 #endif
7526 len += sprintf(buf + len, "\n");
7527 }
7528 }
7529 return len;
7530 }
7531
7532 static int ixj_read_proc(char *page, char **start, off_t off,
7533 int count, int *eof, void *data)
7534 {
7535 int len = ixj_get_status_proc(page);
7536 if (len <= off+count) *eof = 1;
7537 *start = page + off;
7538 len -= off;
7539 if (len>count) len = count;
7540 if (len<0) len = 0;
7541 return len;
7542 }
7543
7544
7545 static void cleanup(void)
7546 {
7547 int cnt;
7548 IXJ *j;
7549
7550 for (cnt = 0; cnt < IXJMAX; cnt++) {
7551 j = get_ixj(cnt);
7552 if(j != NULL && j->DSPbase) {
7553 if (ixjdebug & 0x0002)
7554 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7555 del_timer(&j->timer);
7556 if (j->cardtype == QTI_LINEJACK) {
7557 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7558
7559 outb_p(j->pld_scrw.byte, j->XILINXbase);
7560 j->pld_slicw.bits.rly1 = 0;
7561 j->pld_slicw.bits.rly2 = 0;
7562 j->pld_slicw.bits.rly3 = 0;
7563 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7564 LED_SetState(0x0, j);
7565 if (ixjdebug & 0x0002)
7566 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7567 release_region(j->XILINXbase, 8);
7568 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7569 if (ixjdebug & 0x0002)
7570 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7571 release_region(j->XILINXbase, 4);
7572 }
7573 if (j->read_buffer)
7574 kfree(j->read_buffer);
7575 if (j->write_buffer)
7576 kfree(j->write_buffer);
7577 if (j->dev && j->dev->deactivate)
7578 j->dev->deactivate(j->dev);
7579 if (ixjdebug & 0x0002)
7580 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7581 phone_unregister_device(&j->p);
7582 if (ixjdebug & 0x0002)
7583 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7584 release_region(j->DSPbase, 16);
7585 #ifdef IXJ_DYN_ALLOC
7586 if (ixjdebug & 0x0002)
7587 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7588 kfree(j);
7589 ixj[cnt] = NULL;
7590 #endif
7591 }
7592 }
7593 if (ixjdebug & 0x0002)
7594 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7595 remove_proc_entry ("ixj", NULL);
7596 }
7597
7598 /* Typedefs */
7599 typedef struct {
7600 BYTE length;
7601 DWORD bits;
7602 } DATABLOCK;
7603
7604 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7605 {
7606 lastLCC = lastLCC & 0xfb;
7607 lastLCC = lastLCC | (byData ? 4 : 0);
7608 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7609
7610 mdelay(1);
7611 lastLCC = lastLCC | 0x01;
7612 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7613
7614 byData = byData << 1;
7615 lastLCC = lastLCC & 0xfe;
7616 mdelay(1);
7617 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7618
7619 }
7620
7621 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7622 {
7623 mdelay(1);
7624 lastLCC = lastLCC | 0x01;
7625 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7626
7627 lastLCC = lastLCC & 0xfe;
7628 mdelay(1);
7629 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7630
7631 return ((inb(wEEPROMAddress) >> 3) & 1);
7632 }
7633
7634 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7635 {
7636 BYTE lastLCC;
7637 WORD wEEPROMAddress = wAddress + 3;
7638 DWORD i;
7639 BYTE byResult;
7640 *pwResult = 0;
7641 lastLCC = inb(wEEPROMAddress);
7642 lastLCC = lastLCC | 0x02;
7643 lastLCC = lastLCC & 0xfe;
7644 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7645
7646 mdelay(1); /* delay */
7647
7648 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7649 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7650 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7651 for (i = 0; i < 8; i++) {
7652 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7653 wLoc <<= 1;
7654 }
7655
7656 for (i = 0; i < 16; i++) {
7657 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7658 *pwResult = (*pwResult << 1) | byResult;
7659 }
7660
7661 mdelay(1); /* another delay */
7662
7663 lastLCC = lastLCC & 0xfd;
7664 outb(lastLCC, wEEPROMAddress); /* negate CS */
7665
7666 return 0;
7667 }
7668
7669 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7670 {
7671 WORD wLo, wHi;
7672 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7673 return 0;
7674 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7675 return 0;
7676 return (((DWORD) wHi << 16) | wLo);
7677 }
7678
7679 static int dspio[IXJMAX + 1] =
7680 {
7681 0,
7682 };
7683 static int xio[IXJMAX + 1] =
7684 {
7685 0,
7686 };
7687
7688 MODULE_PARM(dspio, "1-" __MODULE_STRING(IXJMAX) "i");
7689 MODULE_PARM(xio, "1-" __MODULE_STRING(IXJMAX) "i");
7690 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7691 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7692 MODULE_LICENSE("GPL");
7693
7694 void ixj_exit(void)
7695 {
7696 cleanup();
7697 }
7698
7699 int __init ixj_probe_isapnp(int *cnt)
7700 {
7701 int probe = 0;
7702 int func = 0x110;
7703 struct pci_dev *dev = NULL, *old_dev = NULL;
7704
7705 while (1) {
7706 do {
7707 IXJ *j;
7708 int result;
7709
7710 old_dev = dev;
7711 dev = isapnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7712 ISAPNP_FUNCTION(func), old_dev);
7713 if (!dev)
7714 break;
7715 result = dev->prepare(dev);
7716 if (result < 0) {
7717 printk("preparing failed %d \n", result);
7718 break;
7719 }
7720
7721 if (!(dev->resource[0].flags & IORESOURCE_IO))
7722 return -ENODEV;
7723
7724 dev->resource[0].flags |= IORESOURCE_AUTO;
7725 if (func != 0x110)
7726 dev->resource[1].flags |= IORESOURCE_AUTO;
7727 if (dev->activate(dev) < 0) {
7728 printk("isapnp configure failed (out of resources?)\n");
7729 return -ENOMEM;
7730 }
7731
7732 result = check_region(dev->resource[0].start, 16);
7733 if (result) {
7734 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", dev->resource[0].start);
7735 break;
7736 }
7737
7738 j = ixj_alloc();
7739 request_region(j->DSPbase, 16, "ixj DSP");
7740
7741 if (func != 0x110)
7742 j->XILINXbase = dev->resource[1].start; /* get real port */
7743
7744 switch (func) {
7745 case (0x110):
7746 j->cardtype = QTI_PHONEJACK;
7747 break;
7748 case (0x310):
7749 j->cardtype = QTI_LINEJACK;
7750 break;
7751 case (0x410):
7752 j->cardtype = QTI_PHONEJACK_LITE;
7753 break;
7754 }
7755 j->board = *cnt;
7756 probe = ixj_selfprobe(j);
7757 if(!probe) {
7758 j->serial = dev->bus->serial;
7759 j->dev = dev;
7760 switch (func) {
7761 case 0x110:
7762 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7763 break;
7764 case 0x310:
7765 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7766 break;
7767 case 0x410:
7768 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7769 break;
7770 }
7771 }
7772 ++*cnt;
7773 } while (dev);
7774 if (func == 0x410)
7775 break;
7776 if (func == 0x310)
7777 func = 0x410;
7778 if (func == 0x110)
7779 func = 0x310;
7780 dev = NULL;
7781 }
7782 return probe;
7783 }
7784
7785 int __init ixj_probe_isa(int *cnt)
7786 {
7787 int i, result, probe;
7788
7789 /* Use passed parameters for older kernels without PnP */
7790 for (i = 0; i < IXJMAX; i++) {
7791 if (dspio[i]) {
7792 IXJ *j;
7793
7794 if ((result = check_region(ixj[*cnt].DSPbase, 16)) < 0) {
7795 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", ixj[*cnt].DSPbase);
7796 break;
7797 }
7798
7799 j = ixj_alloc();
7800
7801 j->DSPbase = dspio[i];
7802 request_region(j->DSPbase, 16, "ixj DSP");
7803
7804 j->XILINXbase = xio[i];
7805 j->cardtype = 0;
7806
7807 j->board = *cnt;
7808 probe = ixj_selfprobe(j);
7809 j->dev = NULL;
7810 ++*cnt;
7811 }
7812 }
7813 return 0;
7814 }
7815
7816 int __init ixj_probe_pci(int *cnt)
7817 {
7818 struct pci_dev *pci = NULL;
7819 int i, probe = 0;
7820 IXJ *j = NULL;
7821 int result;
7822
7823 if(!pci_present())
7824 return 0;
7825
7826 for (i = 0; i < IXJMAX - *cnt; i++) {
7827 pci = pci_find_device(0x15E2, 0x0500, pci);
7828 if (!pci)
7829 break;
7830
7831 if (pci_enable_device(pci))
7832 break;
7833 if ((result = check_region(pci_resource_start(pci, 0), 16)) < 0) {
7834 printk(KERN_INFO "ixj: can't get I/O address\n");
7835 break;
7836 }
7837
7838 /* Grab a device slot */
7839 j = ixj_alloc();
7840 if(j == NULL)
7841 break;
7842
7843 j->DSPbase = pci_resource_start(pci, 0);
7844 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7845 j->XILINXbase = j->DSPbase + 0x10;
7846 request_region(j->DSPbase, 16, "ixj DSP");
7847 j->cardtype = QTI_PHONEJACK_PCI;
7848 j->board = *cnt;
7849 probe = ixj_selfprobe(j);
7850 if (!probe)
7851 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7852 ++*cnt;
7853 }
7854 return probe;
7855 }
7856
7857 int __init ixj_init(void)
7858 {
7859 int cnt = 0;
7860 int probe = 0;
7861
7862 cnt = 0;
7863
7864 /* These might be no-ops, see above. */
7865 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7866 return probe;
7867 }
7868 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7869 return probe;
7870 }
7871 if (pci_present()) {
7872 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7873 return probe;
7874 }
7875 }
7876 printk("%s\n", ixj_c_rcsid);
7877 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7878 return probe;
7879 }
7880
7881 module_init(ixj_init);
7882 module_exit(ixj_exit);
7883
7884 static void DAA_Coeff_US(IXJ *j)
7885 {
7886 int i;
7887
7888 j->daa_country = DAA_US;
7889 /*----------------------------------------------- */
7890 /* CAO */
7891 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7892 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7893 }
7894
7895 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7896 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7897 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7898 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7899 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7900 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7901 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7902 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7903 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7904 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7905 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7906 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7907 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7908 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7909 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7910 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7911 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7912 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7913 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7914 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7915 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7916 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7917 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7918 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7919 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7920 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7921 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7922 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7923 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7924 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7925 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7926 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7927 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7928 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7929 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7930 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7931 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7932 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7933 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7934 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7935 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7936 /* Bytes for AR-filter (09): 52,D3,11,42 */
7937 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7938 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7939 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7940 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7941 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7942 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7943 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7944 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7945 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7946 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7947 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7948 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7949 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7950 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7951 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7952 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7953 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7954 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7955 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7956 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7957 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7958 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7959 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7960 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7961 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7962 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7963 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7964 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7965 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7966 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7967 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7968 /* ; (10K, 0.68uF) */
7969 /* */
7970 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7971 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7972 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7973 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7974 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7975 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7976 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7977 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7978 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7979 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7980 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7981 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7982 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7983 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7984 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7985 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7986 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7987 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7988
7989 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7990 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7991 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7992 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7993 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7994
7995 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7996 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7997 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7998 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7999 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
8000 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
8001 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
8002 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
8003 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
8004 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8005 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
8006 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
8007 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
8008 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
8009 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
8010 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
8011 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
8012 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
8013 /* */
8014 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8015 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
8016 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
8017 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
8018 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
8019
8020 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8021 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8022 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8023 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8024 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8025 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8026 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8027 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8028 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8029 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8030 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8031 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8032 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8033 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8034 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8035 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8036 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8037 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8038 /* */
8039 /* ;CR Registers */
8040 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
8041 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8042 /* Config. Reg. 1 (dialing) (cr1):05 */
8043 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8044 /* Config. Reg. 2 (caller ID) (cr2):04 */
8045 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8046 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
8047 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8048 /* Config. Reg. 4 (analog gain) (cr4):02 */
8049 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8050 /* Config. Reg. 5 (Version) (cr5):02 */
8051 /* Config. Reg. 6 (Reserved) (cr6):00 */
8052 /* Config. Reg. 7 (Reserved) (cr7):00 */
8053 /* */
8054 /* ;xr Registers */
8055 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8056
8057 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8058 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
8059
8060 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
8061 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8062 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8063 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
8064 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
8065 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8066
8067 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8068 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8069 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8070 /* Ext. Reg. 6 (Power State) (xr6):00 */
8071 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8072 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8073 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8074 /* */
8075 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8076 /* 12,33,5A,C3 ; 770 Hz */
8077 /* 13,3C,5B,32 ; 852 Hz */
8078 /* 1D,1B,5C,CC ; 941 Hz */
8079
8080 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8081 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8082 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8083 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8084 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8085 /* EC,1D,52,22 ; 1336 Hz */
8086 /* AA,AC,51,D2 ; 1477 Hz */
8087 /* 9B,3B,51,25 ; 1633 Hz */
8088 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8089 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8090 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8091 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8092 }
8093
8094 static void DAA_Coeff_UK(IXJ *j)
8095 {
8096 int i;
8097
8098 j->daa_country = DAA_UK;
8099 /*----------------------------------------------- */
8100 /* CAO */
8101 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8102 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8103 }
8104
8105 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8106 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8107 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8108 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8109 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8110 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8111 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8112 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8113 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8114 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8115 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8116 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8117 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8118 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8119 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8120 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8121 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8122 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8123 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
8124 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8125 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8126 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8127 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8128 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8129 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8130 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8131 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8132 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8133 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8134 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8135 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8136 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8137 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8138 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8139 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8140 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8141 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8142 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8143 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8144 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8145 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8146 /* Bytes for AR-filter (09): E2,27,10,D6 */
8147 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8148 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8149 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8150 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8151 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8152 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8153 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8154 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8155 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8156 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8157 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8158 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8159 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8160 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8161 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8162 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8163 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8164 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8165 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8166 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8167 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8168 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8169 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8170 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8171 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8172 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8173 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8174 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8175 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8176 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8177 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8178 /* ; idle */
8179 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8180 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8181 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8182 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8183 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8184 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8185 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8186 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8187 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8188 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8189 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8190 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8191 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8192 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8193 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8194 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8195 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8196 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8197 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8198 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8199 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8200 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8201 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8202 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8203 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8204 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8205 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8206 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8207 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8208 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8209 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8210 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8211 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8212 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8213 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8214 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8215 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8216 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8217 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8218 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8219 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8220 /* ;CR Registers */
8221 /* Config. Reg. 0 (filters) (cr0):FF */
8222 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8223 /* Config. Reg. 1 (dialing) (cr1):05 */
8224 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8225 /* Config. Reg. 2 (caller ID) (cr2):04 */
8226 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8227 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8228 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8229 /* Config. Reg. 4 (analog gain) (cr4):02 */
8230 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8231 /* Config. Reg. 5 (Version) (cr5):02 */
8232 /* Config. Reg. 6 (Reserved) (cr6):00 */
8233 /* Config. Reg. 7 (Reserved) (cr7):00 */
8234 /* ;xr Registers */
8235 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8236
8237 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8238 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8239
8240 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8241 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8242
8243 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8244 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8245 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8246 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8247 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8248 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8249 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8250 /* Ext. Reg. 6 (Power State) (xr6):00 */
8251 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8252 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8253 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8254 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8255 /* 12,33,5A,C3 ; 770 Hz */
8256 /* 13,3C,5B,32 ; 852 Hz */
8257 /* 1D,1B,5C,CC ; 941 Hz */
8258
8259 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8260 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8261 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8262 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8263 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8264 /* EC,1D,52,22 ; 1336 Hz */
8265 /* AA,AC,51,D2 ; 1477 Hz */
8266 /* 9B,3B,51,25 ; 1633 Hz */
8267 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8268 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8269 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8270 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8271 }
8272
8273
8274 static void DAA_Coeff_France(IXJ *j)
8275 {
8276 int i;
8277
8278 j->daa_country = DAA_FRANCE;
8279 /*----------------------------------------------- */
8280 /* CAO */
8281 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8282 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8283 }
8284
8285 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8286 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8287 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8288 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8289 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8290 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8291 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8292 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8293 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8294 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8295 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8296 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8297 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8298 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8299 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8300 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8301 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8302 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8303 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8304 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8305 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8306 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8307 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8308 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8309 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8310 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8311 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8312 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8313 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8314 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8315 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8316 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8317 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8318 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8319 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8320 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8321 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8322 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8323 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8324 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8325 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8326 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8327 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8328 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8329 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8330 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8331 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8332 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8333 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8334 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8335 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8336 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8337 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8338 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8339 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8340 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8341 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8342 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8343 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8344 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8345 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8346 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8347 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8348 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8349 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8350 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8351 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8352 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8353 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8354 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8355 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8356 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8357 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8358 /* ; idle */
8359 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8360 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8361 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8362 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8363 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8364 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8365 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8366 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8367 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8368 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8369 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8370 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8371 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8372 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8373 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8374 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8375 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8376 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8377 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8378 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8379 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8380 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8381 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8382 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8383 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8384 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8385 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8386 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8387 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8388 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8389 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8390 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8391 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8392 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8393 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8394 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8395 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8396 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8397 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8398 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8399 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8400 /* ;CR Registers */
8401 /* Config. Reg. 0 (filters) (cr0):FF */
8402 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8403 /* Config. Reg. 1 (dialing) (cr1):05 */
8404 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8405 /* Config. Reg. 2 (caller ID) (cr2):04 */
8406 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8407 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8408 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8409 /* Config. Reg. 4 (analog gain) (cr4):02 */
8410 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8411 /* Config. Reg. 5 (Version) (cr5):02 */
8412 /* Config. Reg. 6 (Reserved) (cr6):00 */
8413 /* Config. Reg. 7 (Reserved) (cr7):00 */
8414 /* ;xr Registers */
8415 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8416
8417 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8418 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8419
8420 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8421 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8422
8423 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8424 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8425 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8426 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8427 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8428 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8429 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8430 /* Ext. Reg. 6 (Power State) (xr6):00 */
8431 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8432 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8433 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8434 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8435 /* 12,33,5A,C3 ; 770 Hz */
8436 /* 13,3C,5B,32 ; 852 Hz */
8437 /* 1D,1B,5C,CC ; 941 Hz */
8438
8439 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8440 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8441 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8442 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8443 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8444 /* EC,1D,52,22 ; 1336 Hz */
8445 /* AA,AC,51,D2 ; 1477 Hz */
8446 /* 9B,3B,51,25 ; 1633 Hz */
8447 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8448 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8449 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8450 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8451 }
8452
8453
8454 static void DAA_Coeff_Germany(IXJ *j)
8455 {
8456 int i;
8457
8458 j->daa_country = DAA_GERMANY;
8459 /*----------------------------------------------- */
8460 /* CAO */
8461 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8462 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8463 }
8464
8465 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8466 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8467 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8468 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8469 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8470 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8471 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8472 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8473 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8474 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8475 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8476 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8477 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8478 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8479 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8480 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8481 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8482 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8483 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8484 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8485 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8486 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8487 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8488 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8489 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8490 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8491 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8492 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8493 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8494 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8495 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8496 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8497 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8498 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8499 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8500 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8501 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8502 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8503 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8504 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8505 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8506 /* Bytes for AR-filter (09): 72,42,13,4B */
8507 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8508 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8509 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8510 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8511 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8512 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8513 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8514 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8515 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8516 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8517 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8518 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8519 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8520 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8521 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8522 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8523 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8524 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8525 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8526 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8527 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8528 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8529 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8530 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8531 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8532 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8533 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8534 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8535 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8536 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8537 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8538 /* ; (10K, 0.68uF) */
8539 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8540 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8541 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8542 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8543 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8544 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8545 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8546 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8547 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8548 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8549 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8550 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8551 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8552 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8553 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8554 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8555 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8556 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8557 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8558 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8559 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8560 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8561 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8562 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8563 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8564 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8565 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8566 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8567 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8568 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8569 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8570 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8571 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8572 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8573 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8574 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8575 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8576 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8577 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8578 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8579 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8580 /* ;CR Registers */
8581 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8582 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8583 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8584 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8585 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8586 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8587 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8588 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8589 /* Config. Reg. 4 (analog gain) (cr4):02 */
8590 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8591 /* Config. Reg. 5 (Version) (cr5):02 */
8592 /* Config. Reg. 6 (Reserved) (cr6):00 */
8593 /* Config. Reg. 7 (Reserved) (cr7):00 */
8594 /* ;xr Registers */
8595 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8596
8597 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8598 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8599
8600 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8601 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8602
8603 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8604 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8605 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8606 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8607 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8608 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8609 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8610 /* Ext. Reg. 6 (Power State) (xr6):00 */
8611 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8612 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8613 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8614 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8615 /* 12,33,5A,C3 ; 770 Hz */
8616 /* 13,3C,5B,32 ; 852 Hz */
8617 /* 1D,1B,5C,CC ; 941 Hz */
8618
8619 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8620 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8621 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8622 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8623 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8624 /* EC,1D,52,22 ; 1336 Hz */
8625 /* AA,AC,51,D2 ; 1477 Hz */
8626 /* 9B,3B,51,25 ; 1633 Hz */
8627 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8628 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8629 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8630 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8631 }
8632
8633
8634 static void DAA_Coeff_Australia(IXJ *j)
8635 {
8636 int i;
8637
8638 j->daa_country = DAA_AUSTRALIA;
8639 /*----------------------------------------------- */
8640 /* CAO */
8641 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8642 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8643 }
8644
8645 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8646 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8647 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8648 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8649 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8650 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8651 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8652 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8653 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8654 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8655 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8656 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8657 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8658 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8659 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8660 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8661 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8662 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8663 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8664 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8665 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8666 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8667 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8668 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8669 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8670 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8671 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8672 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8673 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8674 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8675 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8676 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8677 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8678 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8679 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8680 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8681 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8682 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8683 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8684 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8685 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8686 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8687 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8688 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8689 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8690 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8691 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8692 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8693 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8694 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8695 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8696 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8697 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8698 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8699 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8700 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8701 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8702 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8703 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8704 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8705 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8706 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8707 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8708 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8709 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8710 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8711 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8712 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8713 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8714 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8715 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8716 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8717 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8718 /* ; idle */
8719 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8720 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8721 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8722 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8723 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8724 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8725 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8726 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8727 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8728 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8729 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8730 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8731 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8732 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8733 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8734 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8735 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8736 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8737 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8738 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8739 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8740 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8741 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8742 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8743 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8744 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8745 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8746 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8747 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8748 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8749 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8750 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8751 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8752 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8753 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8754 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8755 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8756 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8757 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8758 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8759 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8760 /* ;CR Registers */
8761 /* Config. Reg. 0 (filters) (cr0):FF */
8762 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8763 /* Config. Reg. 1 (dialing) (cr1):05 */
8764 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8765 /* Config. Reg. 2 (caller ID) (cr2):04 */
8766 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8767 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8768 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8769 /* Config. Reg. 4 (analog gain) (cr4):02 */
8770 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8771 /* Config. Reg. 5 (Version) (cr5):02 */
8772 /* Config. Reg. 6 (Reserved) (cr6):00 */
8773 /* Config. Reg. 7 (Reserved) (cr7):00 */
8774 /* ;xr Registers */
8775 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8776
8777 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8778 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8779
8780 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8781 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8782
8783 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8784 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8785 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8786 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8787 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8788 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8789 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8790 /* Ext. Reg. 6 (Power State) (xr6):00 */
8791 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8792 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8793 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8794
8795 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8796 /* 12,33,5A,C3 ; 770 Hz */
8797 /* 13,3C,5B,32 ; 852 Hz */
8798 /* 1D,1B,5C,CC ; 941 Hz */
8799 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8800 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8801 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8802 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8803
8804 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8805 /* EC,1D,52,22 ; 1336 Hz */
8806 /* AA,AC,51,D2 ; 1477 Hz */
8807 /* 9B,3B,51,25 ; 1633 Hz */
8808 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8809 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8810 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8811 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8812 }
8813
8814 static void DAA_Coeff_Japan(IXJ *j)
8815 {
8816 int i;
8817
8818 j->daa_country = DAA_JAPAN;
8819 /*----------------------------------------------- */
8820 /* CAO */
8821 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8822 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8823 }
8824
8825 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8826 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8827 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8828 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8829 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8830 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8831 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8832 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8833 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8834 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8835 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8836 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8837 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8838 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8839 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8840 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8841 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8842 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8843 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8844 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8845 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8846 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8847 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8848 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8849 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8850 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8851 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8852 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8853 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8854 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8855 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8856 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8857 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8858 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8859 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8860 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8861 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8862 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8863 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8864 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8865 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8866 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8867 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8868 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8869 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8870 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8871 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8872 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8873 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8874 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8875 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8876 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8877 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8878 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8879 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8880 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8881 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8882 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8883 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8884 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8885 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8886 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8887 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8888 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8889 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8890 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8891 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8892 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8893 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8894 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8895 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8896 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8897 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8898 /* ; idle */
8899 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8900 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8901 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8902 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8903 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8904 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8905 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8906 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8907 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8908 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8909 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8910 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8911 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8912 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8913 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8914 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8915 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8916 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8917 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8918 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8919 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8920 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8921 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8922 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8923 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8924 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8925 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8926 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8927 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8928 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8929 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8930 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8931 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8932 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8933 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8934 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8935 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8936 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8937 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8938 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8939 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8940 /* ;CR Registers */
8941 /* Config. Reg. 0 (filters) (cr0):FF */
8942 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8943 /* Config. Reg. 1 (dialing) (cr1):05 */
8944 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8945 /* Config. Reg. 2 (caller ID) (cr2):04 */
8946 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8947 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8948 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8949 /* Config. Reg. 4 (analog gain) (cr4):02 */
8950 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8951 /* Config. Reg. 5 (Version) (cr5):02 */
8952 /* Config. Reg. 6 (Reserved) (cr6):00 */
8953 /* Config. Reg. 7 (Reserved) (cr7):00 */
8954 /* ;xr Registers */
8955 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8956
8957 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8958 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8959
8960 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8961 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8962
8963 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8964 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8965 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8966 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8967 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8968 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8969 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8970 /* Ext. Reg. 6 (Power State) (xr6):00 */
8971 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8972 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8973 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8974 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8975 /* 12,33,5A,C3 ; 770 Hz */
8976 /* 13,3C,5B,32 ; 852 Hz */
8977 /* 1D,1B,5C,CC ; 941 Hz */
8978
8979 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8980 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8981 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8982 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8983 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8984 /* EC,1D,52,22 ; 1336 Hz */
8985 /* AA,AC,51,D2 ; 1477 Hz */
8986 /* 9B,3B,51,25 ; 1633 Hz */
8987 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8988 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8989 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8990 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8991 }
8992
8993 static s16 tone_table[][19] =
8994 {
8995 { /* f20_50[] 11 */
8996 32538, /* A1 = 1.985962 */
8997 -32325, /* A2 = -0.986511 */
8998 -343, /* B2 = -0.010493 */
8999 0, /* B1 = 0 */
9000 343, /* B0 = 0.010493 */
9001 32619, /* A1 = 1.990906 */
9002 -32520, /* A2 = -0.992462 */
9003 19179, /* B2 = 0.585327 */
9004 -19178, /* B1 = -1.170593 */
9005 19179, /* B0 = 0.585327 */
9006 32723, /* A1 = 1.997314 */
9007 -32686, /* A2 = -0.997528 */
9008 9973, /* B2 = 0.304352 */
9009 -9955, /* B1 = -0.607605 */
9010 9973, /* B0 = 0.304352 */
9011 7, /* Internal filter scaling */
9012 159, /* Minimum in-band energy threshold */
9013 21, /* 21/32 in-band to broad-band ratio */
9014 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9015 },
9016 { /* f133_200[] 12 */
9017 32072, /* A1 = 1.95752 */
9018 -31896, /* A2 = -0.973419 */
9019 -435, /* B2 = -0.013294 */
9020 0, /* B1 = 0 */
9021 435, /* B0 = 0.013294 */
9022 32188, /* A1 = 1.9646 */
9023 -32400, /* A2 = -0.98877 */
9024 15139, /* B2 = 0.462036 */
9025 -14882, /* B1 = -0.908356 */
9026 15139, /* B0 = 0.462036 */
9027 32473, /* A1 = 1.981995 */
9028 -32524, /* A2 = -0.992584 */
9029 23200, /* B2 = 0.708008 */
9030 -23113, /* B1 = -1.410706 */
9031 23200, /* B0 = 0.708008 */
9032 7, /* Internal filter scaling */
9033 159, /* Minimum in-band energy threshold */
9034 21, /* 21/32 in-band to broad-band ratio */
9035 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9036 },
9037 { /* f300 13 */
9038 31769, /* A1 = -1.939026 */
9039 -32584, /* A2 = 0.994385 */
9040 -475, /* B2 = -0.014522 */
9041 0, /* B1 = 0.000000 */
9042 475, /* B0 = 0.014522 */
9043 31789, /* A1 = -1.940247 */
9044 -32679, /* A2 = 0.997284 */
9045 17280, /* B2 = 0.527344 */
9046 -16865, /* B1 = -1.029358 */
9047 17280, /* B0 = 0.527344 */
9048 31841, /* A1 = -1.943481 */
9049 -32681, /* A2 = 0.997345 */
9050 543, /* B2 = 0.016579 */
9051 -525, /* B1 = -0.032097 */
9052 543, /* B0 = 0.016579 */
9053 5, /* Internal filter scaling */
9054 159, /* Minimum in-band energy threshold */
9055 21, /* 21/32 in-band to broad-band ratio */
9056 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9057 },
9058 { /* f300_420[] 14 */
9059 30750, /* A1 = 1.876892 */
9060 -31212, /* A2 = -0.952515 */
9061 -804, /* B2 = -0.024541 */
9062 0, /* B1 = 0 */
9063 804, /* B0 = 0.024541 */
9064 30686, /* A1 = 1.872925 */
9065 -32145, /* A2 = -0.980988 */
9066 14747, /* B2 = 0.450043 */
9067 -13703, /* B1 = -0.836395 */
9068 14747, /* B0 = 0.450043 */
9069 31651, /* A1 = 1.931824 */
9070 -32321, /* A2 = -0.986389 */
9071 24425, /* B2 = 0.745422 */
9072 -23914, /* B1 = -1.459595 */
9073 24427, /* B0 = 0.745483 */
9074 7, /* Internal filter scaling */
9075 159, /* Minimum in-band energy threshold */
9076 21, /* 21/32 in-band to broad-band ratio */
9077 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9078 },
9079 { /* f330 15 */
9080 31613, /* A1 = -1.929565 */
9081 -32646, /* A2 = 0.996277 */
9082 -185, /* B2 = -0.005657 */
9083 0, /* B1 = 0.000000 */
9084 185, /* B0 = 0.005657 */
9085 31620, /* A1 = -1.929932 */
9086 -32713, /* A2 = 0.998352 */
9087 19253, /* B2 = 0.587585 */
9088 -18566, /* B1 = -1.133179 */
9089 19253, /* B0 = 0.587585 */
9090 31674, /* A1 = -1.933228 */
9091 -32715, /* A2 = 0.998413 */
9092 2575, /* B2 = 0.078590 */
9093 -2495, /* B1 = -0.152283 */
9094 2575, /* B0 = 0.078590 */
9095 5, /* Internal filter scaling */
9096 159, /* Minimum in-band energy threshold */
9097 21, /* 21/32 in-band to broad-band ratio */
9098 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9099 },
9100 { /* f300_425[] 16 */
9101 30741, /* A1 = 1.876282 */
9102 -31475, /* A2 = -0.960541 */
9103 -703, /* B2 = -0.021484 */
9104 0, /* B1 = 0 */
9105 703, /* B0 = 0.021484 */
9106 30688, /* A1 = 1.873047 */
9107 -32248, /* A2 = -0.984161 */
9108 14542, /* B2 = 0.443787 */
9109 -13523, /* B1 = -0.825439 */
9110 14542, /* B0 = 0.443817 */
9111 31494, /* A1 = 1.922302 */
9112 -32366, /* A2 = -0.987762 */
9113 21577, /* B2 = 0.658508 */
9114 -21013, /* B1 = -1.282532 */
9115 21577, /* B0 = 0.658508 */
9116 7, /* Internal filter scaling */
9117 159, /* Minimum in-band energy threshold */
9118 21, /* 21/32 in-band to broad-band ratio */
9119 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9120 },
9121 { /* f330_440[] 17 */
9122 30627, /* A1 = 1.869324 */
9123 -31338, /* A2 = -0.95636 */
9124 -843, /* B2 = -0.025749 */
9125 0, /* B1 = 0 */
9126 843, /* B0 = 0.025749 */
9127 30550, /* A1 = 1.864685 */
9128 -32221, /* A2 = -0.983337 */
9129 13594, /* B2 = 0.414886 */
9130 -12589, /* B1 = -0.768402 */
9131 13594, /* B0 = 0.414886 */
9132 31488, /* A1 = 1.921936 */
9133 -32358, /* A2 = -0.987518 */
9134 24684, /* B2 = 0.753296 */
9135 -24029, /* B1 = -1.466614 */
9136 24684, /* B0 = 0.753296 */
9137 7, /* Internal filter scaling */
9138 159, /* Minimum in-band energy threshold */
9139 21, /* 21/32 in-band to broad-band ratio */
9140 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9141 },
9142 { /* f340 18 */
9143 31546, /* A1 = -1.925476 */
9144 -32646, /* A2 = 0.996277 */
9145 -445, /* B2 = -0.013588 */
9146 0, /* B1 = 0.000000 */
9147 445, /* B0 = 0.013588 */
9148 31551, /* A1 = -1.925781 */
9149 -32713, /* A2 = 0.998352 */
9150 23884, /* B2 = 0.728882 */
9151 -22979, /* B1 = -1.402527 */
9152 23884, /* B0 = 0.728882 */
9153 31606, /* A1 = -1.929138 */
9154 -32715, /* A2 = 0.998413 */
9155 863, /* B2 = 0.026367 */
9156 -835, /* B1 = -0.050985 */
9157 863, /* B0 = 0.026367 */
9158 5, /* Internal filter scaling */
9159 159, /* Minimum in-band energy threshold */
9160 21, /* 21/32 in-band to broad-band ratio */
9161 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9162 },
9163 { /* f350_400[] 19 */
9164 31006, /* A1 = 1.892517 */
9165 -32029, /* A2 = -0.977448 */
9166 -461, /* B2 = -0.014096 */
9167 0, /* B1 = 0 */
9168 461, /* B0 = 0.014096 */
9169 30999, /* A1 = 1.892029 */
9170 -32487, /* A2 = -0.991455 */
9171 11325, /* B2 = 0.345612 */
9172 -10682, /* B1 = -0.651978 */
9173 11325, /* B0 = 0.345612 */
9174 31441, /* A1 = 1.919067 */
9175 -32526, /* A2 = -0.992615 */
9176 24324, /* B2 = 0.74231 */
9177 -23535, /* B1 = -1.436523 */
9178 24324, /* B0 = 0.74231 */
9179 7, /* Internal filter scaling */
9180 159, /* Minimum in-band energy threshold */
9181 21, /* 21/32 in-band to broad-band ratio */
9182 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9183 },
9184 { /* f350_440[] */
9185 30634, /* A1 = 1.869751 */
9186 -31533, /* A2 = -0.962341 */
9187 -680, /* B2 = -0.020782 */
9188 0, /* B1 = 0 */
9189 680, /* B0 = 0.020782 */
9190 30571, /* A1 = 1.865906 */
9191 -32277, /* A2 = -0.985016 */
9192 12894, /* B2 = 0.393524 */
9193 -11945, /* B1 = -0.729065 */
9194 12894, /* B0 = 0.393524 */
9195 31367, /* A1 = 1.91449 */
9196 -32379, /* A2 = -0.988129 */
9197 23820, /* B2 = 0.726929 */
9198 -23104, /* B1 = -1.410217 */
9199 23820, /* B0 = 0.726929 */
9200 7, /* Internal filter scaling */
9201 159, /* Minimum in-band energy threshold */
9202 21, /* 21/32 in-band to broad-band ratio */
9203 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9204 },
9205 { /* f350_450[] */
9206 30552, /* A1 = 1.864807 */
9207 -31434, /* A2 = -0.95929 */
9208 -690, /* B2 = -0.021066 */
9209 0, /* B1 = 0 */
9210 690, /* B0 = 0.021066 */
9211 30472, /* A1 = 1.859924 */
9212 -32248, /* A2 = -0.984161 */
9213 13385, /* B2 = 0.408478 */
9214 -12357, /* B1 = -0.754242 */
9215 13385, /* B0 = 0.408478 */
9216 31358, /* A1 = 1.914001 */
9217 -32366, /* A2 = -0.987732 */
9218 26488, /* B2 = 0.80835 */
9219 -25692, /* B1 = -1.568176 */
9220 26490, /* B0 = 0.808411 */
9221 7, /* Internal filter scaling */
9222 159, /* Minimum in-band energy threshold */
9223 21, /* 21/32 in-band to broad-band ratio */
9224 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9225 },
9226 { /* f360 */
9227 31397, /* A1 = -1.916321 */
9228 -32623, /* A2 = 0.995605 */
9229 -117, /* B2 = -0.003598 */
9230 0, /* B1 = 0.000000 */
9231 117, /* B0 = 0.003598 */
9232 31403, /* A1 = -1.916687 */
9233 -32700, /* A2 = 0.997925 */
9234 3388, /* B2 = 0.103401 */
9235 -3240, /* B1 = -0.197784 */
9236 3388, /* B0 = 0.103401 */
9237 31463, /* A1 = -1.920410 */
9238 -32702, /* A2 = 0.997986 */
9239 13346, /* B2 = 0.407288 */
9240 -12863, /* B1 = -0.785126 */
9241 13346, /* B0 = 0.407288 */
9242 5, /* Internal filter scaling */
9243 159, /* Minimum in-band energy threshold */
9244 21, /* 21/32 in-band to broad-band ratio */
9245 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9246 },
9247 { /* f380_420[] */
9248 30831, /* A1 = 1.881775 */
9249 -32064, /* A2 = -0.978546 */
9250 -367, /* B2 = -0.01122 */
9251 0, /* B1 = 0 */
9252 367, /* B0 = 0.01122 */
9253 30813, /* A1 = 1.880737 */
9254 -32456, /* A2 = -0.990509 */
9255 11068, /* B2 = 0.337769 */
9256 -10338, /* B1 = -0.631042 */
9257 11068, /* B0 = 0.337769 */
9258 31214, /* A1 = 1.905212 */
9259 -32491, /* A2 = -0.991577 */
9260 16374, /* B2 = 0.499695 */
9261 -15781, /* B1 = -0.963196 */
9262 16374, /* B0 = 0.499695 */
9263 7, /* Internal filter scaling */
9264 159, /* Minimum in-band energy threshold */
9265 21, /* 21/32 in-band to broad-band ratio */
9266 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9267 },
9268 { /* f392 */
9269 31152, /* A1 = -1.901428 */
9270 -32613, /* A2 = 0.995300 */
9271 -314, /* B2 = -0.009605 */
9272 0, /* B1 = 0.000000 */
9273 314, /* B0 = 0.009605 */
9274 31156, /* A1 = -1.901672 */
9275 -32694, /* A2 = 0.997742 */
9276 28847, /* B2 = 0.880371 */
9277 -2734, /* B1 = -0.166901 */
9278 28847, /* B0 = 0.880371 */
9279 31225, /* A1 = -1.905823 */
9280 -32696, /* A2 = 0.997803 */
9281 462, /* B2 = 0.014108 */
9282 -442, /* B1 = -0.027019 */
9283 462, /* B0 = 0.014108 */
9284 5, /* Internal filter scaling */
9285 159, /* Minimum in-band energy threshold */
9286 21, /* 21/32 in-band to broad-band ratio */
9287 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9288 },
9289 { /* f400_425[] */
9290 30836, /* A1 = 1.882141 */
9291 -32296, /* A2 = -0.985596 */
9292 -324, /* B2 = -0.009903 */
9293 0, /* B1 = 0 */
9294 324, /* B0 = 0.009903 */
9295 30825, /* A1 = 1.881409 */
9296 -32570, /* A2 = -0.993958 */
9297 16847, /* B2 = 0.51416 */
9298 -15792, /* B1 = -0.963898 */
9299 16847, /* B0 = 0.51416 */
9300 31106, /* A1 = 1.89856 */
9301 -32584, /* A2 = -0.994415 */
9302 9579, /* B2 = 0.292328 */
9303 -9164, /* B1 = -0.559357 */
9304 9579, /* B0 = 0.292328 */
9305 7, /* Internal filter scaling */
9306 159, /* Minimum in-band energy threshold */
9307 21, /* 21/32 in-band to broad-band ratio */
9308 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9309 },
9310 { /* f400_440[] */
9311 30702, /* A1 = 1.873962 */
9312 -32134, /* A2 = -0.980682 */
9313 -517, /* B2 = -0.015793 */
9314 0, /* B1 = 0 */
9315 517, /* B0 = 0.015793 */
9316 30676, /* A1 = 1.872375 */
9317 -32520, /* A2 = -0.992462 */
9318 8144, /* B2 = 0.24855 */
9319 -7596, /* B1 = -0.463684 */
9320 8144, /* B0 = 0.24855 */
9321 31084, /* A1 = 1.897217 */
9322 -32547, /* A2 = -0.993256 */
9323 22713, /* B2 = 0.693176 */
9324 -21734, /* B1 = -1.326599 */
9325 22713, /* B0 = 0.693176 */
9326 7, /* Internal filter scaling */
9327 159, /* Minimum in-band energy threshold */
9328 21, /* 21/32 in-band to broad-band ratio */
9329 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9330 },
9331 { /* f400_450[] */
9332 30613, /* A1 = 1.86853 */
9333 -32031, /* A2 = -0.977509 */
9334 -618, /* B2 = -0.018866 */
9335 0, /* B1 = 0 */
9336 618, /* B0 = 0.018866 */
9337 30577, /* A1 = 1.866272 */
9338 -32491, /* A2 = -0.991577 */
9339 9612, /* B2 = 0.293335 */
9340 -8935, /* B1 = -0.54541 */
9341 9612, /* B0 = 0.293335 */
9342 31071, /* A1 = 1.896484 */
9343 -32524, /* A2 = -0.992584 */
9344 21596, /* B2 = 0.659058 */
9345 -20667, /* B1 = -1.261414 */
9346 21596, /* B0 = 0.659058 */
9347 7, /* Internal filter scaling */
9348 159, /* Minimum in-band energy threshold */
9349 21, /* 21/32 in-band to broad-band ratio */
9350 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9351 },
9352 { /* f420 */
9353 30914, /* A1 = -1.886841 */
9354 -32584, /* A2 = 0.994385 */
9355 -426, /* B2 = -0.013020 */
9356 0, /* B1 = 0.000000 */
9357 426, /* B0 = 0.013020 */
9358 30914, /* A1 = -1.886841 */
9359 -32679, /* A2 = 0.997314 */
9360 17520, /* B2 = 0.534668 */
9361 -16471, /* B1 = -1.005310 */
9362 17520, /* B0 = 0.534668 */
9363 31004, /* A1 = -1.892334 */
9364 -32683, /* A2 = 0.997406 */
9365 819, /* B2 = 0.025023 */
9366 -780, /* B1 = -0.047619 */
9367 819, /* B0 = 0.025023 */
9368 5, /* Internal filter scaling */
9369 159, /* Minimum in-band energy threshold */
9370 21, /* 21/32 in-band to broad-band ratio */
9371 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9372 },
9373 #if 0
9374 { /* f425 */
9375 30881, /* A1 = -1.884827 */
9376 -32603, /* A2 = 0.994965 */
9377 -496, /* B2 = -0.015144 */
9378 0, /* B1 = 0.000000 */
9379 496, /* B0 = 0.015144 */
9380 30880, /* A1 = -1.884766 */
9381 -32692, /* A2 = 0.997711 */
9382 24767, /* B2 = 0.755859 */
9383 -23290, /* B1 = -1.421509 */
9384 24767, /* B0 = 0.755859 */
9385 30967, /* A1 = -1.890076 */
9386 -32694, /* A2 = 0.997772 */
9387 728, /* B2 = 0.022232 */
9388 -691, /* B1 = -0.042194 */
9389 728, /* B0 = 0.022232 */
9390 5, /* Internal filter scaling */
9391 159, /* Minimum in-band energy threshold */
9392 21, /* 21/32 in-band to broad-band ratio */
9393 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394 },
9395 #else
9396 {
9397 30850,
9398 -32534,
9399 -504,
9400 0,
9401 504,
9402 30831,
9403 -32669,
9404 24303,
9405 -22080,
9406 24303,
9407 30994,
9408 -32673,
9409 1905,
9410 -1811,
9411 1905,
9412 5,
9413 129,
9414 17,
9415 0xff5
9416 },
9417 #endif
9418 { /* f425_450[] */
9419 30646, /* A1 = 1.870544 */
9420 -32327, /* A2 = -0.986572 */
9421 -287, /* B2 = -0.008769 */
9422 0, /* B1 = 0 */
9423 287, /* B0 = 0.008769 */
9424 30627, /* A1 = 1.869324 */
9425 -32607, /* A2 = -0.995087 */
9426 13269, /* B2 = 0.404968 */
9427 -12376, /* B1 = -0.755432 */
9428 13269, /* B0 = 0.404968 */
9429 30924, /* A1 = 1.887512 */
9430 -32619, /* A2 = -0.995453 */
9431 19950, /* B2 = 0.608826 */
9432 -18940, /* B1 = -1.156006 */
9433 19950, /* B0 = 0.608826 */
9434 7, /* Internal filter scaling */
9435 159, /* Minimum in-band energy threshold */
9436 21, /* 21/32 in-band to broad-band ratio */
9437 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9438 },
9439 { /* f425_475[] */
9440 30396, /* A1 = 1.855225 */
9441 -32014, /* A2 = -0.97699 */
9442 -395, /* B2 = -0.012055 */
9443 0, /* B1 = 0 */
9444 395, /* B0 = 0.012055 */
9445 30343, /* A1 = 1.85199 */
9446 -32482, /* A2 = -0.991302 */
9447 17823, /* B2 = 0.543945 */
9448 -16431, /* B1 = -1.002869 */
9449 17823, /* B0 = 0.543945 */
9450 30872, /* A1 = 1.884338 */
9451 -32516, /* A2 = -0.99231 */
9452 18124, /* B2 = 0.553101 */
9453 -17246, /* B1 = -1.052673 */
9454 18124, /* B0 = 0.553101 */
9455 7, /* Internal filter scaling */
9456 159, /* Minimum in-band energy threshold */
9457 21, /* 21/32 in-band to broad-band ratio */
9458 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9459 },
9460 { /* f435 */
9461 30796, /* A1 = -1.879639 */
9462 -32603, /* A2 = 0.994965 */
9463 -254, /* B2 = -0.007762 */
9464 0, /* B1 = 0.000000 */
9465 254, /* B0 = 0.007762 */
9466 30793, /* A1 = -1.879456 */
9467 -32692, /* A2 = 0.997711 */
9468 18934, /* B2 = 0.577820 */
9469 -17751, /* B1 = -1.083496 */
9470 18934, /* B0 = 0.577820 */
9471 30882, /* A1 = -1.884888 */
9472 -32694, /* A2 = 0.997772 */
9473 1858, /* B2 = 0.056713 */
9474 -1758, /* B1 = -0.107357 */
9475 1858, /* B0 = 0.056713 */
9476 5, /* Internal filter scaling */
9477 159, /* Minimum in-band energy threshold */
9478 21, /* 21/32 in-band to broad-band ratio */
9479 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9480 },
9481 { /* f440_450[] */
9482 30641, /* A1 = 1.870239 */
9483 -32458, /* A2 = -0.99057 */
9484 -155, /* B2 = -0.004735 */
9485 0, /* B1 = 0 */
9486 155, /* B0 = 0.004735 */
9487 30631, /* A1 = 1.869568 */
9488 -32630, /* A2 = -0.995789 */
9489 11453, /* B2 = 0.349548 */
9490 -10666, /* B1 = -0.651001 */
9491 11453, /* B0 = 0.349548 */
9492 30810, /* A1 = 1.880554 */
9493 -32634, /* A2 = -0.995941 */
9494 12237, /* B2 = 0.373474 */
9495 -11588, /* B1 = -0.707336 */
9496 12237, /* B0 = 0.373474 */
9497 7, /* Internal filter scaling */
9498 159, /* Minimum in-band energy threshold */
9499 21, /* 21/32 in-band to broad-band ratio */
9500 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9501 },
9502 { /* f440_480[] */
9503 30367, /* A1 = 1.853455 */
9504 -32147, /* A2 = -0.981079 */
9505 -495, /* B2 = -0.015113 */
9506 0, /* B1 = 0 */
9507 495, /* B0 = 0.015113 */
9508 30322, /* A1 = 1.850769 */
9509 -32543, /* A2 = -0.993134 */
9510 10031, /* B2 = 0.306152 */
9511 -9252, /* B1 = -0.564728 */
9512 10031, /* B0 = 0.306152 */
9513 30770, /* A1 = 1.878052 */
9514 -32563, /* A2 = -0.993774 */
9515 22674, /* B2 = 0.691956 */
9516 -21465, /* B1 = -1.31012 */
9517 22674, /* B0 = 0.691956 */
9518 7, /* Internal filter scaling */
9519 159, /* Minimum in-band energy threshold */
9520 21, /* 21/32 in-band to broad-band ratio */
9521 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9522 },
9523 { /* f445 */
9524 30709, /* A1 = -1.874329 */
9525 -32603, /* A2 = 0.994965 */
9526 -83, /* B2 = -0.002545 */
9527 0, /* B1 = 0.000000 */
9528 83, /* B0 = 0.002545 */
9529 30704, /* A1 = -1.874084 */
9530 -32692, /* A2 = 0.997711 */
9531 10641, /* B2 = 0.324738 */
9532 -9947, /* B1 = -0.607147 */
9533 10641, /* B0 = 0.324738 */
9534 30796, /* A1 = -1.879639 */
9535 -32694, /* A2 = 0.997772 */
9536 10079, /* B2 = 0.307587 */
9537 9513, /* B1 = 0.580688 */
9538 10079, /* B0 = 0.307587 */
9539 5, /* Internal filter scaling */
9540 159, /* Minimum in-band energy threshold */
9541 21, /* 21/32 in-band to broad-band ratio */
9542 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9543 },
9544 { /* f450 */
9545 30664, /* A1 = -1.871643 */
9546 -32603, /* A2 = 0.994965 */
9547 -164, /* B2 = -0.005029 */
9548 0, /* B1 = 0.000000 */
9549 164, /* B0 = 0.005029 */
9550 30661, /* A1 = -1.871399 */
9551 -32692, /* A2 = 0.997711 */
9552 15294, /* B2 = 0.466736 */
9553 -14275, /* B1 = -0.871307 */
9554 15294, /* B0 = 0.466736 */
9555 30751, /* A1 = -1.876953 */
9556 -32694, /* A2 = 0.997772 */
9557 3548, /* B2 = 0.108284 */
9558 -3344, /* B1 = -0.204155 */
9559 3548, /* B0 = 0.108284 */
9560 5, /* Internal filter scaling */
9561 159, /* Minimum in-band energy threshold */
9562 21, /* 21/32 in-band to broad-band ratio */
9563 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9564 },
9565 { /* f452 */
9566 30653, /* A1 = -1.870911 */
9567 -32615, /* A2 = 0.995361 */
9568 -209, /* B2 = -0.006382 */
9569 0, /* B1 = 0.000000 */
9570 209, /* B0 = 0.006382 */
9571 30647, /* A1 = -1.870605 */
9572 -32702, /* A2 = 0.997986 */
9573 18971, /* B2 = 0.578979 */
9574 -17716, /* B1 = -1.081299 */
9575 18971, /* B0 = 0.578979 */
9576 30738, /* A1 = -1.876099 */
9577 -32702, /* A2 = 0.998016 */
9578 2967, /* B2 = 0.090561 */
9579 -2793, /* B1 = -0.170502 */
9580 2967, /* B0 = 0.090561 */
9581 5, /* Internal filter scaling */
9582 159, /* Minimum in-band energy threshold */
9583 21, /* 21/32 in-band to broad-band ratio */
9584 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9585 },
9586 { /* f475 */
9587 30437, /* A1 = -1.857727 */
9588 -32603, /* A2 = 0.994965 */
9589 -264, /* B2 = -0.008062 */
9590 0, /* B1 = 0.000000 */
9591 264, /* B0 = 0.008062 */
9592 30430, /* A1 = -1.857300 */
9593 -32692, /* A2 = 0.997711 */
9594 21681, /* B2 = 0.661682 */
9595 -20082, /* B1 = -1.225708 */
9596 21681, /* B0 = 0.661682 */
9597 30526, /* A1 = -1.863220 */
9598 -32694, /* A2 = 0.997742 */
9599 1559, /* B2 = 0.047600 */
9600 -1459, /* B1 = -0.089096 */
9601 1559, /* B0 = 0.047600 */
9602 5, /* Internal filter scaling */
9603 159, /* Minimum in-band energy threshold */
9604 21, /* 21/32 in-band to broad-band ratio */
9605 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9606 },
9607 { /* f480_620[] */
9608 28975, /* A1 = 1.768494 */
9609 -30955, /* A2 = -0.944672 */
9610 -1026, /* B2 = -0.03133 */
9611 0, /* B1 = 0 */
9612 1026, /* B0 = 0.03133 */
9613 28613, /* A1 = 1.746399 */
9614 -32089, /* A2 = -0.979309 */
9615 14214, /* B2 = 0.433807 */
9616 -12202, /* B1 = -0.744812 */
9617 14214, /* B0 = 0.433807 */
9618 30243, /* A1 = 1.845947 */
9619 -32238, /* A2 = -0.983856 */
9620 24825, /* B2 = 0.757629 */
9621 -23402, /* B1 = -1.428345 */
9622 24825, /* B0 = 0.757629 */
9623 7, /* Internal filter scaling */
9624 159, /* Minimum in-band energy threshold */
9625 21, /* 21/32 in-band to broad-band ratio */
9626 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9627 },
9628 { /* f494 */
9629 30257, /* A1 = -1.846741 */
9630 -32605, /* A2 = 0.995056 */
9631 -249, /* B2 = -0.007625 */
9632 0, /* B1 = 0.000000 */
9633 249, /* B0 = 0.007625 */
9634 30247, /* A1 = -1.846191 */
9635 -32694, /* A2 = 0.997772 */
9636 18088, /* B2 = 0.552002 */
9637 -16652, /* B1 = -1.016418 */
9638 18088, /* B0 = 0.552002 */
9639 30348, /* A1 = -1.852295 */
9640 -32696, /* A2 = 0.997803 */
9641 2099, /* B2 = 0.064064 */
9642 -1953, /* B1 = -0.119202 */
9643 2099, /* B0 = 0.064064 */
9644 5, /* Internal filter scaling */
9645 159, /* Minimum in-band energy threshold */
9646 21, /* 21/32 in-band to broad-band ratio */
9647 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9648 },
9649 { /* f500 */
9650 30202, /* A1 = -1.843431 */
9651 -32624, /* A2 = 0.995622 */
9652 -413, /* B2 = -0.012622 */
9653 0, /* B1 = 0.000000 */
9654 413, /* B0 = 0.012622 */
9655 30191, /* A1 = -1.842721 */
9656 -32714, /* A2 = 0.998364 */
9657 25954, /* B2 = 0.792057 */
9658 -23890, /* B1 = -1.458131 */
9659 25954, /* B0 = 0.792057 */
9660 30296, /* A1 = -1.849172 */
9661 -32715, /* A2 = 0.998397 */
9662 2007, /* B2 = 0.061264 */
9663 -1860, /* B1 = -0.113568 */
9664 2007, /* B0 = 0.061264 */
9665 5, /* Internal filter scaling */
9666 159, /* Minimum in-band energy threshold */
9667 21, /* 21/32 in-band to broad-band ratio */
9668 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9669 },
9670 { /* f520 */
9671 30001, /* A1 = -1.831116 */
9672 -32613, /* A2 = 0.995270 */
9673 -155, /* B2 = -0.004750 */
9674 0, /* B1 = 0.000000 */
9675 155, /* B0 = 0.004750 */
9676 29985, /* A1 = -1.830200 */
9677 -32710, /* A2 = 0.998260 */
9678 6584, /* B2 = 0.200928 */
9679 -6018, /* B1 = -0.367355 */
9680 6584, /* B0 = 0.200928 */
9681 30105, /* A1 = -1.837524 */
9682 -32712, /* A2 = 0.998291 */
9683 23812, /* B2 = 0.726685 */
9684 -21936, /* B1 = -1.338928 */
9685 23812, /* B0 = 0.726685 */
9686 5, /* Internal filter scaling */
9687 159, /* Minimum in-band energy threshold */
9688 21, /* 21/32 in-band to broad-band ratio */
9689 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9690 },
9691 { /* f523 */
9692 29964, /* A1 = -1.828918 */
9693 -32601, /* A2 = 0.994904 */
9694 -101, /* B2 = -0.003110 */
9695 0, /* B1 = 0.000000 */
9696 101, /* B0 = 0.003110 */
9697 29949, /* A1 = -1.827942 */
9698 -32700, /* A2 = 0.997925 */
9699 11041, /* B2 = 0.336975 */
9700 -10075, /* B1 = -0.614960 */
9701 11041, /* B0 = 0.336975 */
9702 30070, /* A1 = -1.835388 */
9703 -32702, /* A2 = 0.997986 */
9704 16762, /* B2 = 0.511536 */
9705 -15437, /* B1 = -0.942230 */
9706 16762, /* B0 = 0.511536 */
9707 5, /* Internal filter scaling */
9708 159, /* Minimum in-band energy threshold */
9709 21, /* 21/32 in-band to broad-band ratio */
9710 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9711 },
9712 { /* f525 */
9713 29936, /* A1 = -1.827209 */
9714 -32584, /* A2 = 0.994415 */
9715 -91, /* B2 = -0.002806 */
9716 0, /* B1 = 0.000000 */
9717 91, /* B0 = 0.002806 */
9718 29921, /* A1 = -1.826233 */
9719 -32688, /* A2 = 0.997559 */
9720 11449, /* B2 = 0.349396 */
9721 -10426, /* B1 = -0.636383 */
9722 11449, /* B0 = 0.349396 */
9723 30045, /* A1 = -1.833862 */
9724 -32688, /* A2 = 0.997589 */
9725 13055, /* B2 = 0.398407 */
9726 -12028, /* B1 = -0.734161 */
9727 13055, /* B0 = 0.398407 */
9728 5, /* Internal filter scaling */
9729 159, /* Minimum in-band energy threshold */
9730 21, /* 21/32 in-band to broad-band ratio */
9731 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9732 },
9733 { /* f540_660[] */
9734 28499, /* A1 = 1.739441 */
9735 -31129, /* A2 = -0.949982 */
9736 -849, /* B2 = -0.025922 */
9737 0, /* B1 = 0 */
9738 849, /* B0 = 0.025922 */
9739 28128, /* A1 = 1.716797 */
9740 -32130, /* A2 = -0.98056 */
9741 14556, /* B2 = 0.444214 */
9742 -12251, /* B1 = -0.747772 */
9743 14556, /* B0 = 0.444244 */
9744 29667, /* A1 = 1.81073 */
9745 -32244, /* A2 = -0.984039 */
9746 23038, /* B2 = 0.703064 */
9747 -21358, /* B1 = -1.303589 */
9748 23040, /* B0 = 0.703125 */
9749 7, /* Internal filter scaling */
9750 159, /* Minimum in-band energy threshold */
9751 21, /* 21/32 in-band to broad-band ratio */
9752 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9753 },
9754 { /* f587 */
9755 29271, /* A1 = -1.786560 */
9756 -32599, /* A2 = 0.994873 */
9757 -490, /* B2 = -0.014957 */
9758 0, /* B1 = 0.000000 */
9759 490, /* B0 = 0.014957 */
9760 29246, /* A1 = -1.785095 */
9761 -32700, /* A2 = 0.997925 */
9762 28961, /* B2 = 0.883850 */
9763 -25796, /* B1 = -1.574463 */
9764 28961, /* B0 = 0.883850 */
9765 29383, /* A1 = -1.793396 */
9766 -32700, /* A2 = 0.997955 */
9767 1299, /* B2 = 0.039650 */
9768 -1169, /* B1 = -0.071396 */
9769 1299, /* B0 = 0.039650 */
9770 5, /* Internal filter scaling */
9771 159, /* Minimum in-band energy threshold */
9772 21, /* 21/32 in-band to broad-band ratio */
9773 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9774 },
9775 { /* f590 */
9776 29230, /* A1 = -1.784058 */
9777 -32584, /* A2 = 0.994415 */
9778 -418, /* B2 = -0.012757 */
9779 0, /* B1 = 0.000000 */
9780 418, /* B0 = 0.012757 */
9781 29206, /* A1 = -1.782593 */
9782 -32688, /* A2 = 0.997559 */
9783 36556, /* B2 = 1.115601 */
9784 -32478, /* B1 = -1.982300 */
9785 36556, /* B0 = 1.115601 */
9786 29345, /* A1 = -1.791077 */
9787 -32688, /* A2 = 0.997589 */
9788 897, /* B2 = 0.027397 */
9789 -808, /* B1 = -0.049334 */
9790 897, /* B0 = 0.027397 */
9791 5, /* Internal filter scaling */
9792 159, /* Minimum in-band energy threshold */
9793 21, /* 21/32 in-band to broad-band ratio */
9794 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9795 },
9796 { /* f600 */
9797 29116, /* A1 = -1.777100 */
9798 -32603, /* A2 = 0.994965 */
9799 -165, /* B2 = -0.005039 */
9800 0, /* B1 = 0.000000 */
9801 165, /* B0 = 0.005039 */
9802 29089, /* A1 = -1.775452 */
9803 -32708, /* A2 = 0.998199 */
9804 6963, /* B2 = 0.212494 */
9805 -6172, /* B1 = -0.376770 */
9806 6963, /* B0 = 0.212494 */
9807 29237, /* A1 = -1.784485 */
9808 -32710, /* A2 = 0.998230 */
9809 24197, /* B2 = 0.738464 */
9810 -21657, /* B1 = -1.321899 */
9811 24197, /* B0 = 0.738464 */
9812 5, /* Internal filter scaling */
9813 159, /* Minimum in-band energy threshold */
9814 21, /* 21/32 in-band to broad-band ratio */
9815 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9816 },
9817 { /* f660 */
9818 28376, /* A1 = -1.731934 */
9819 -32567, /* A2 = 0.993896 */
9820 -363, /* B2 = -0.011102 */
9821 0, /* B1 = 0.000000 */
9822 363, /* B0 = 0.011102 */
9823 28337, /* A1 = -1.729614 */
9824 -32683, /* A2 = 0.997434 */
9825 21766, /* B2 = 0.664246 */
9826 -18761, /* B1 = -1.145081 */
9827 21766, /* B0 = 0.664246 */
9828 28513, /* A1 = -1.740356 */
9829 -32686, /* A2 = 0.997498 */
9830 2509, /* B2 = 0.076584 */
9831 -2196, /* B1 = -0.134041 */
9832 2509, /* B0 = 0.076584 */
9833 5, /* Internal filter scaling */
9834 159, /* Minimum in-band energy threshold */
9835 21, /* 21/32 in-band to broad-band ratio */
9836 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9837 },
9838 { /* f700 */
9839 27844, /* A1 = -1.699463 */
9840 -32563, /* A2 = 0.993744 */
9841 -366, /* B2 = -0.011187 */
9842 0, /* B1 = 0.000000 */
9843 366, /* B0 = 0.011187 */
9844 27797, /* A1 = -1.696655 */
9845 -32686, /* A2 = 0.997498 */
9846 22748, /* B2 = 0.694214 */
9847 -19235, /* B1 = -1.174072 */
9848 22748, /* B0 = 0.694214 */
9849 27995, /* A1 = -1.708740 */
9850 -32688, /* A2 = 0.997559 */
9851 2964, /* B2 = 0.090477 */
9852 -2546, /* B1 = -0.155449 */
9853 2964, /* B0 = 0.090477 */
9854 5, /* Internal filter scaling */
9855 159, /* Minimum in-band energy threshold */
9856 21, /* 21/32 in-band to broad-band ratio */
9857 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9858 },
9859 { /* f740 */
9860 27297, /* A1 = -1.666077 */
9861 -32551, /* A2 = 0.993408 */
9862 -345, /* B2 = -0.010540 */
9863 0, /* B1 = 0.000000 */
9864 345, /* B0 = 0.010540 */
9865 27240, /* A1 = -1.662598 */
9866 -32683, /* A2 = 0.997406 */
9867 22560, /* B2 = 0.688477 */
9868 -18688, /* B1 = -1.140625 */
9869 22560, /* B0 = 0.688477 */
9870 27461, /* A1 = -1.676147 */
9871 -32684, /* A2 = 0.997467 */
9872 3541, /* B2 = 0.108086 */
9873 -2985, /* B1 = -0.182220 */
9874 3541, /* B0 = 0.108086 */
9875 5, /* Internal filter scaling */
9876 159, /* Minimum in-band energy threshold */
9877 21, /* 21/32 in-band to broad-band ratio */
9878 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9879 },
9880 { /* f750 */
9881 27155, /* A1 = -1.657410 */
9882 -32551, /* A2 = 0.993408 */
9883 -462, /* B2 = -0.014117 */
9884 0, /* B1 = 0.000000 */
9885 462, /* B0 = 0.014117 */
9886 27097, /* A1 = -1.653870 */
9887 -32683, /* A2 = 0.997406 */
9888 32495, /* B2 = 0.991699 */
9889 -26776, /* B1 = -1.634338 */
9890 32495, /* B0 = 0.991699 */
9891 27321, /* A1 = -1.667542 */
9892 -32684, /* A2 = 0.997467 */
9893 1835, /* B2 = 0.056007 */
9894 -1539, /* B1 = -0.093948 */
9895 1835, /* B0 = 0.056007 */
9896 5, /* Internal filter scaling */
9897 159, /* Minimum in-band energy threshold */
9898 21, /* 21/32 in-band to broad-band ratio */
9899 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9900 },
9901 { /* f750_1450[] */
9902 19298, /* A1 = 1.177917 */
9903 -24471, /* A2 = -0.746796 */
9904 -4152, /* B2 = -0.126709 */
9905 0, /* B1 = 0 */
9906 4152, /* B0 = 0.126709 */
9907 12902, /* A1 = 0.787476 */
9908 -29091, /* A2 = -0.887817 */
9909 12491, /* B2 = 0.38121 */
9910 -1794, /* B1 = -0.109528 */
9911 12494, /* B0 = 0.381317 */
9912 26291, /* A1 = 1.604736 */
9913 -30470, /* A2 = -0.929901 */
9914 28859, /* B2 = 0.880737 */
9915 -26084, /* B1 = -1.592102 */
9916 28861, /* B0 = 0.880798 */
9917 7, /* Internal filter scaling */
9918 159, /* Minimum in-band energy threshold */
9919 21, /* 21/32 in-band to broad-band ratio */
9920 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9921 },
9922 { /* f770 */
9923 26867, /* A1 = -1.639832 */
9924 -32551, /* A2 = 0.993408 */
9925 -123, /* B2 = -0.003755 */
9926 0, /* B1 = 0.000000 */
9927 123, /* B0 = 0.003755 */
9928 26805, /* A1 = -1.636108 */
9929 -32683, /* A2 = 0.997406 */
9930 17297, /* B2 = 0.527863 */
9931 -14096, /* B1 = -0.860382 */
9932 17297, /* B0 = 0.527863 */
9933 27034, /* A1 = -1.650085 */
9934 -32684, /* A2 = 0.997467 */
9935 12958, /* B2 = 0.395477 */
9936 -10756, /* B1 = -0.656525 */
9937 12958, /* B0 = 0.395477 */
9938 5, /* Internal filter scaling */
9939 159, /* Minimum in-band energy threshold */
9940 21, /* 21/32 in-band to broad-band ratio */
9941 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9942 },
9943 { /* f800 */
9944 26413, /* A1 = -1.612122 */
9945 -32547, /* A2 = 0.993286 */
9946 -223, /* B2 = -0.006825 */
9947 0, /* B1 = 0.000000 */
9948 223, /* B0 = 0.006825 */
9949 26342, /* A1 = -1.607849 */
9950 -32686, /* A2 = 0.997498 */
9951 6391, /* B2 = 0.195053 */
9952 -5120, /* B1 = -0.312531 */
9953 6391, /* B0 = 0.195053 */
9954 26593, /* A1 = -1.623108 */
9955 -32688, /* A2 = 0.997559 */
9956 23681, /* B2 = 0.722717 */
9957 -19328, /* B1 = -1.179688 */
9958 23681, /* B0 = 0.722717 */
9959 5, /* Internal filter scaling */
9960 159, /* Minimum in-band energy threshold */
9961 21, /* 21/32 in-band to broad-band ratio */
9962 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9963 },
9964 { /* f816 */
9965 26168, /* A1 = -1.597209 */
9966 -32528, /* A2 = 0.992706 */
9967 -235, /* B2 = -0.007182 */
9968 0, /* B1 = 0.000000 */
9969 235, /* B0 = 0.007182 */
9970 26092, /* A1 = -1.592590 */
9971 -32675, /* A2 = 0.997192 */
9972 20823, /* B2 = 0.635498 */
9973 -16510, /* B1 = -1.007751 */
9974 20823, /* B0 = 0.635498 */
9975 26363, /* A1 = -1.609070 */
9976 -32677, /* A2 = 0.997253 */
9977 6739, /* B2 = 0.205688 */
9978 -5459, /* B1 = -0.333206 */
9979 6739, /* B0 = 0.205688 */
9980 5, /* Internal filter scaling */
9981 159, /* Minimum in-band energy threshold */
9982 21, /* 21/32 in-band to broad-band ratio */
9983 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9984 },
9985 { /* f850 */
9986 25641, /* A1 = -1.565063 */
9987 -32536, /* A2 = 0.992950 */
9988 -121, /* B2 = -0.003707 */
9989 0, /* B1 = 0.000000 */
9990 121, /* B0 = 0.003707 */
9991 25560, /* A1 = -1.560059 */
9992 -32684, /* A2 = 0.997437 */
9993 18341, /* B2 = 0.559753 */
9994 -14252, /* B1 = -0.869904 */
9995 18341, /* B0 = 0.559753 */
9996 25837, /* A1 = -1.577026 */
9997 -32684, /* A2 = 0.997467 */
9998 16679, /* B2 = 0.509003 */
9999 -13232, /* B1 = -0.807648 */
10000 16679, /* B0 = 0.509003 */
10001 5, /* Internal filter scaling */
10002 159, /* Minimum in-band energy threshold */
10003 21, /* 21/32 in-band to broad-band ratio */
10004 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10005 },
10006 { /* f857_1645[] */
10007 16415, /* A1 = 1.001953 */
10008 -23669, /* A2 = -0.722321 */
10009 -4549, /* B2 = -0.138847 */
10010 0, /* B1 = 0 */
10011 4549, /* B0 = 0.138847 */
10012 8456, /* A1 = 0.516174 */
10013 -28996, /* A2 = -0.884918 */
10014 13753, /* B2 = 0.419724 */
10015 -12, /* B1 = -0.000763 */
10016 13757, /* B0 = 0.419846 */
10017 24632, /* A1 = 1.503418 */
10018 -30271, /* A2 = -0.923828 */
10019 29070, /* B2 = 0.887146 */
10020 -25265, /* B1 = -1.542114 */
10021 29073, /* B0 = 0.887268 */
10022 7, /* Internal filter scaling */
10023 159, /* Minimum in-band energy threshold */
10024 21, /* 21/32 in-band to broad-band ratio */
10025 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10026 },
10027 { /* f900 */
10028 24806, /* A1 = -1.514099 */
10029 -32501, /* A2 = 0.991852 */
10030 -326, /* B2 = -0.009969 */
10031 0, /* B1 = 0.000000 */
10032 326, /* B0 = 0.009969 */
10033 24709, /* A1 = -1.508118 */
10034 -32659, /* A2 = 0.996674 */
10035 20277, /* B2 = 0.618835 */
10036 -15182, /* B1 = -0.926636 */
10037 20277, /* B0 = 0.618835 */
10038 25022, /* A1 = -1.527222 */
10039 -32661, /* A2 = 0.996735 */
10040 4320, /* B2 = 0.131836 */
10041 -3331, /* B1 = -0.203339 */
10042 4320, /* B0 = 0.131836 */
10043 5, /* Internal filter scaling */
10044 159, /* Minimum in-band energy threshold */
10045 21, /* 21/32 in-band to broad-band ratio */
10046 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10047 },
10048 { /* f900_1300[] */
10049 19776, /* A1 = 1.207092 */
10050 -27437, /* A2 = -0.837341 */
10051 -2666, /* B2 = -0.081371 */
10052 0, /* B1 = 0 */
10053 2666, /* B0 = 0.081371 */
10054 16302, /* A1 = 0.995026 */
10055 -30354, /* A2 = -0.926361 */
10056 10389, /* B2 = 0.317062 */
10057 -3327, /* B1 = -0.203064 */
10058 10389, /* B0 = 0.317062 */
10059 24299, /* A1 = 1.483154 */
10060 -30930, /* A2 = -0.943909 */
10061 25016, /* B2 = 0.763428 */
10062 -21171, /* B1 = -1.292236 */
10063 25016, /* B0 = 0.763428 */
10064 7, /* Internal filter scaling */
10065 159, /* Minimum in-band energy threshold */
10066 21, /* 21/32 in-band to broad-band ratio */
10067 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10068 },
10069 { /* f935_1215[] */
10070 20554, /* A1 = 1.254517 */
10071 -28764, /* A2 = -0.877838 */
10072 -2048, /* B2 = -0.062515 */
10073 0, /* B1 = 0 */
10074 2048, /* B0 = 0.062515 */
10075 18209, /* A1 = 1.11145 */
10076 -30951, /* A2 = -0.94458 */
10077 9390, /* B2 = 0.286575 */
10078 -3955, /* B1 = -0.241455 */
10079 9390, /* B0 = 0.286575 */
10080 23902, /* A1 = 1.458923 */
10081 -31286, /* A2 = -0.954803 */
10082 23252, /* B2 = 0.709595 */
10083 -19132, /* B1 = -1.167725 */
10084 23252, /* B0 = 0.709595 */
10085 7, /* Internal filter scaling */
10086 159, /* Minimum in-band energy threshold */
10087 21, /* 21/32 in-band to broad-band ratio */
10088 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10089 },
10090 { /* f941_1477[] */
10091 17543, /* A1 = 1.07074 */
10092 -26220, /* A2 = -0.800201 */
10093 -3298, /* B2 = -0.100647 */
10094 0, /* B1 = 0 */
10095 3298, /* B0 = 0.100647 */
10096 12423, /* A1 = 0.75827 */
10097 -30036, /* A2 = -0.916626 */
10098 12651, /* B2 = 0.386078 */
10099 -2444, /* B1 = -0.14917 */
10100 12653, /* B0 = 0.386154 */
10101 23518, /* A1 = 1.435425 */
10102 -30745, /* A2 = -0.938293 */
10103 27282, /* B2 = 0.832581 */
10104 -22529, /* B1 = -1.375122 */
10105 27286, /* B0 = 0.832703 */
10106 7, /* Internal filter scaling */
10107 159, /* Minimum in-band energy threshold */
10108 21, /* 21/32 in-band to broad-band ratio */
10109 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10110 },
10111 { /* f942 */
10112 24104, /* A1 = -1.471252 */
10113 -32507, /* A2 = 0.992065 */
10114 -351, /* B2 = -0.010722 */
10115 0, /* B1 = 0.000000 */
10116 351, /* B0 = 0.010722 */
10117 23996, /* A1 = -1.464600 */
10118 -32671, /* A2 = 0.997040 */
10119 22848, /* B2 = 0.697266 */
10120 -16639, /* B1 = -1.015564 */
10121 22848, /* B0 = 0.697266 */
10122 24332, /* A1 = -1.485168 */
10123 -32673, /* A2 = 0.997101 */
10124 4906, /* B2 = 0.149727 */
10125 -3672, /* B1 = -0.224174 */
10126 4906, /* B0 = 0.149727 */
10127 5, /* Internal filter scaling */
10128 159, /* Minimum in-band energy threshold */
10129 21, /* 21/32 in-band to broad-band ratio */
10130 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10131 },
10132 { /* f950 */
10133 23967, /* A1 = -1.462830 */
10134 -32507, /* A2 = 0.992065 */
10135 -518, /* B2 = -0.015821 */
10136 0, /* B1 = 0.000000 */
10137 518, /* B0 = 0.015821 */
10138 23856, /* A1 = -1.456055 */
10139 -32671, /* A2 = 0.997040 */
10140 26287, /* B2 = 0.802246 */
10141 -19031, /* B1 = -1.161560 */
10142 26287, /* B0 = 0.802246 */
10143 24195, /* A1 = -1.476746 */
10144 -32673, /* A2 = 0.997101 */
10145 2890, /* B2 = 0.088196 */
10146 -2151, /* B1 = -0.131317 */
10147 2890, /* B0 = 0.088196 */
10148 5, /* Internal filter scaling */
10149 159, /* Minimum in-band energy threshold */
10150 21, /* 21/32 in-band to broad-band ratio */
10151 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10152 },
10153 { /* f950_1400[] */
10154 18294, /* A1 = 1.116638 */
10155 -26962, /* A2 = -0.822845 */
10156 -2914, /* B2 = -0.088936 */
10157 0, /* B1 = 0 */
10158 2914, /* B0 = 0.088936 */
10159 14119, /* A1 = 0.861786 */
10160 -30227, /* A2 = -0.922455 */
10161 11466, /* B2 = 0.349945 */
10162 -2833, /* B1 = -0.172943 */
10163 11466, /* B0 = 0.349945 */
10164 23431, /* A1 = 1.430115 */
10165 -30828, /* A2 = -0.940796 */
10166 25331, /* B2 = 0.773071 */
10167 -20911, /* B1 = -1.276367 */
10168 25331, /* B0 = 0.773071 */
10169 7, /* Internal filter scaling */
10170 159, /* Minimum in-band energy threshold */
10171 21, /* 21/32 in-band to broad-band ratio */
10172 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10173 },
10174 { /* f975 */
10175 23521, /* A1 = -1.435608 */
10176 -32489, /* A2 = 0.991516 */
10177 -193, /* B2 = -0.005915 */
10178 0, /* B1 = 0.000000 */
10179 193, /* B0 = 0.005915 */
10180 23404, /* A1 = -1.428467 */
10181 -32655, /* A2 = 0.996582 */
10182 17740, /* B2 = 0.541412 */
10183 -12567, /* B1 = -0.767029 */
10184 17740, /* B0 = 0.541412 */
10185 23753, /* A1 = -1.449829 */
10186 -32657, /* A2 = 0.996613 */
10187 9090, /* B2 = 0.277405 */
10188 -6662, /* B1 = -0.406647 */
10189 9090, /* B0 = 0.277405 */
10190 5, /* Internal filter scaling */
10191 159, /* Minimum in-band energy threshold */
10192 21, /* 21/32 in-band to broad-band ratio */
10193 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10194 },
10195 { /* f1000 */
10196 23071, /* A1 = -1.408203 */
10197 -32489, /* A2 = 0.991516 */
10198 -293, /* B2 = -0.008965 */
10199 0, /* B1 = 0.000000 */
10200 293, /* B0 = 0.008965 */
10201 22951, /* A1 = -1.400818 */
10202 -32655, /* A2 = 0.996582 */
10203 5689, /* B2 = 0.173645 */
10204 -3951, /* B1 = -0.241150 */
10205 5689, /* B0 = 0.173645 */
10206 23307, /* A1 = -1.422607 */
10207 -32657, /* A2 = 0.996613 */
10208 18692, /* B2 = 0.570435 */
10209 -13447, /* B1 = -0.820770 */
10210 18692, /* B0 = 0.570435 */
10211 5, /* Internal filter scaling */
10212 159, /* Minimum in-band energy threshold */
10213 21, /* 21/32 in-band to broad-band ratio */
10214 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10215 },
10216 { /* f1020 */
10217 22701, /* A1 = -1.385620 */
10218 -32474, /* A2 = 0.991058 */
10219 -292, /* B2 = -0.008933 */
10220 0, /*163840 , B1 = 10.000000 */
10221 292, /* B0 = 0.008933 */
10222 22564, /* A1 = -1.377258 */
10223 -32655, /* A2 = 0.996552 */
10224 20756, /* B2 = 0.633423 */
10225 -14176, /* B1 = -0.865295 */
10226 20756, /* B0 = 0.633423 */
10227 22960, /* A1 = -1.401428 */
10228 -32657, /* A2 = 0.996613 */
10229 6520, /* B2 = 0.198990 */
10230 -4619, /* B1 = -0.281937 */
10231 6520, /* B0 = 0.198990 */
10232 5, /* Internal filter scaling */
10233 159, /* Minimum in-band energy threshold */
10234 21, /* 21/32 in-band to broad-band ratio */
10235 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10236 },
10237 { /* f1050 */
10238 22142, /* A1 = -1.351501 */
10239 -32474, /* A2 = 0.991058 */
10240 -147, /* B2 = -0.004493 */
10241 0, /* B1 = 0.000000 */
10242 147, /* B0 = 0.004493 */
10243 22000, /* A1 = -1.342834 */
10244 -32655, /* A2 = 0.996552 */
10245 15379, /* B2 = 0.469360 */
10246 -10237, /* B1 = -0.624847 */
10247 15379, /* B0 = 0.469360 */
10248 22406, /* A1 = -1.367554 */
10249 -32657, /* A2 = 0.996613 */
10250 17491, /* B2 = 0.533783 */
10251 -12096, /* B1 = -0.738312 */
10252 17491, /* B0 = 0.533783 */
10253 5, /* Internal filter scaling */
10254 159, /* Minimum in-band energy threshold */
10255 21, /* 21/32 in-band to broad-band ratio */
10256 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10257 },
10258 { /* f1100_1750[] */
10259 12973, /* A1 = 0.79184 */
10260 -24916, /* A2 = -0.760376 */
10261 6655, /* B2 = 0.203102 */
10262 367, /* B1 = 0.0224 */
10263 6657, /* B0 = 0.203171 */
10264 5915, /* A1 = 0.361053 */
10265 -29560, /* A2 = -0.90213 */
10266 -7777, /* B2 = -0.23735 */
10267 0, /* B1 = 0 */
10268 7777, /* B0 = 0.23735 */
10269 20510, /* A1 = 1.251892 */
10270 -30260, /* A2 = -0.923462 */
10271 26662, /* B2 = 0.81366 */
10272 -20573, /* B1 = -1.255737 */
10273 26668, /* B0 = 0.813843 */
10274 7, /* Internal filter scaling */
10275 159, /* Minimum in-band energy threshold */
10276 21, /* 21/32 in-band to broad-band ratio */
10277 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10278 },
10279 { /* f1140 */
10280 20392, /* A1 = -1.244629 */
10281 -32460, /* A2 = 0.990601 */
10282 -270, /* B2 = -0.008240 */
10283 0, /* B1 = 0.000000 */
10284 270, /* B0 = 0.008240 */
10285 20218, /* A1 = -1.234009 */
10286 -32655, /* A2 = 0.996582 */
10287 21337, /* B2 = 0.651154 */
10288 -13044, /* B1 = -0.796143 */
10289 21337, /* B0 = 0.651154 */
10290 20684, /* A1 = -1.262512 */
10291 -32657, /* A2 = 0.996643 */
10292 8572, /* B2 = 0.261612 */
10293 -5476, /* B1 = -0.334244 */
10294 8572, /* B0 = 0.261612 */
10295 5, /* Internal filter scaling */
10296 159, /* Minimum in-band energy threshold */
10297 21, /* 21/32 in-band to broad-band ratio */
10298 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10299 },
10300 { /* f1200 */
10301 19159, /* A1 = -1.169373 */
10302 -32456, /* A2 = 0.990509 */
10303 -335, /* B2 = -0.010252 */
10304 0, /* B1 = 0.000000 */
10305 335, /* B0 = 0.010252 */
10306 18966, /* A1 = -1.157593 */
10307 -32661, /* A2 = 0.996735 */
10308 6802, /* B2 = 0.207588 */
10309 -3900, /* B1 = -0.238098 */
10310 6802, /* B0 = 0.207588 */
10311 19467, /* A1 = -1.188232 */
10312 -32661, /* A2 = 0.996765 */
10313 25035, /* B2 = 0.764008 */
10314 -15049, /* B1 = -0.918579 */
10315 25035, /* B0 = 0.764008 */
10316 5, /* Internal filter scaling */
10317 159, /* Minimum in-band energy threshold */
10318 21, /* 21/32 in-band to broad-band ratio */
10319 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10320 },
10321 { /* f1209 */
10322 18976, /* A1 = -1.158264 */
10323 -32439, /* A2 = 0.989990 */
10324 -183, /* B2 = -0.005588 */
10325 0, /* B1 = 0.000000 */
10326 183, /* B0 = 0.005588 */
10327 18774, /* A1 = -1.145874 */
10328 -32650, /* A2 = 0.996429 */
10329 15468, /* B2 = 0.472076 */
10330 -8768, /* B1 = -0.535217 */
10331 15468, /* B0 = 0.472076 */
10332 19300, /* A1 = -1.177979 */
10333 -32652, /* A2 = 0.996490 */
10334 19840, /* B2 = 0.605499 */
10335 -11842, /* B1 = -0.722809 */
10336 19840, /* B0 = 0.605499 */
10337 5, /* Internal filter scaling */
10338 159, /* Minimum in-band energy threshold */
10339 21, /* 21/32 in-band to broad-band ratio */
10340 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10341 },
10342 { /* f1330 */
10343 16357, /* A1 = -0.998413 */
10344 -32368, /* A2 = 0.987793 */
10345 -217, /* B2 = -0.006652 */
10346 0, /* B1 = 0.000000 */
10347 217, /* B0 = 0.006652 */
10348 16107, /* A1 = -0.983126 */
10349 -32601, /* A2 = 0.994904 */
10350 11602, /* B2 = 0.354065 */
10351 -5555, /* B1 = -0.339111 */
10352 11602, /* B0 = 0.354065 */
10353 16722, /* A1 = -1.020630 */
10354 -32603, /* A2 = 0.994965 */
10355 15574, /* B2 = 0.475311 */
10356 -8176, /* B1 = -0.499069 */
10357 15574, /* B0 = 0.475311 */
10358 5, /* Internal filter scaling */
10359 159, /* Minimum in-band energy threshold */
10360 21, /* 21/32 in-band to broad-band ratio */
10361 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10362 },
10363 { /* f1336 */
10364 16234, /* A1 = -0.990875 */
10365 32404, /* A2 = -0.988922 */
10366 -193, /* B2 = -0.005908 */
10367 0, /* B1 = 0.000000 */
10368 193, /* B0 = 0.005908 */
10369 15986, /* A1 = -0.975769 */
10370 -32632, /* A2 = 0.995880 */
10371 18051, /* B2 = 0.550903 */
10372 -8658, /* B1 = -0.528473 */
10373 18051, /* B0 = 0.550903 */
10374 16591, /* A1 = -1.012695 */
10375 -32634, /* A2 = 0.995941 */
10376 15736, /* B2 = 0.480240 */
10377 -8125, /* B1 = -0.495926 */
10378 15736, /* B0 = 0.480240 */
10379 5, /* Internal filter scaling */
10380 159, /* Minimum in-band energy threshold */
10381 21, /* 21/32 in-band to broad-band ratio */
10382 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10383 },
10384 { /* f1366 */
10385 15564, /* A1 = -0.949982 */
10386 -32404, /* A2 = 0.988922 */
10387 -269, /* B2 = -0.008216 */
10388 0, /* B1 = 0.000000 */
10389 269, /* B0 = 0.008216 */
10390 15310, /* A1 = -0.934479 */
10391 -32632, /* A2 = 0.995880 */
10392 10815, /* B2 = 0.330063 */
10393 -4962, /* B1 = -0.302887 */
10394 10815, /* B0 = 0.330063 */
10395 15924, /* A1 = -0.971924 */
10396 -32634, /* A2 = 0.995941 */
10397 18880, /* B2 = 0.576172 */
10398 -9364, /* B1 = -0.571594 */
10399 18880, /* B0 = 0.576172 */
10400 5, /* Internal filter scaling */
10401 159, /* Minimum in-band energy threshold */
10402 21, /* 21/32 in-band to broad-band ratio */
10403 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10404 },
10405 { /* f1380 */
10406 15247, /* A1 = -0.930603 */
10407 -32397, /* A2 = 0.988708 */
10408 -244, /* B2 = -0.007451 */
10409 0, /* B1 = 0.000000 */
10410 244, /* B0 = 0.007451 */
10411 14989, /* A1 = -0.914886 */
10412 -32627, /* A2 = 0.995697 */
10413 18961, /* B2 = 0.578644 */
10414 -8498, /* B1 = -0.518707 */
10415 18961, /* B0 = 0.578644 */
10416 15608, /* A1 = -0.952667 */
10417 -32628, /* A2 = 0.995758 */
10418 11145, /* B2 = 0.340134 */
10419 -5430, /* B1 = -0.331467 */
10420 11145, /* B0 = 0.340134 */
10421 5, /* Internal filter scaling */
10422 159, /* Minimum in-band energy threshold */
10423 21, /* 21/32 in-band to broad-band ratio */
10424 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10425 },
10426 { /* f1400 */
10427 14780, /* A1 = -0.902130 */
10428 -32393, /* A2 = 0.988586 */
10429 -396, /* B2 = -0.012086 */
10430 0, /* B1 = 0.000000 */
10431 396, /* B0 = 0.012086 */
10432 14510, /* A1 = -0.885651 */
10433 -32630, /* A2 = 0.995819 */
10434 6326, /* B2 = 0.193069 */
10435 -2747, /* B1 = -0.167671 */
10436 6326, /* B0 = 0.193069 */
10437 15154, /* A1 = -0.924957 */
10438 -32632, /* A2 = 0.995850 */
10439 23235, /* B2 = 0.709076 */
10440 -10983, /* B1 = -0.670380 */
10441 23235, /* B0 = 0.709076 */
10442 5, /* Internal filter scaling */
10443 159, /* Minimum in-band energy threshold */
10444 21, /* 21/32 in-band to broad-band ratio */
10445 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10446 },
10447 { /* f1477 */
10448 13005, /* A1 = -0.793793 */
10449 -32368, /* A2 = 0.987823 */
10450 -500, /* B2 = -0.015265 */
10451 0, /* B1 = 0.000000 */
10452 500, /* B0 = 0.015265 */
10453 12708, /* A1 = -0.775665 */
10454 -32615, /* A2 = 0.995331 */
10455 11420, /* B2 = 0.348526 */
10456 -4306, /* B1 = -0.262833 */
10457 11420, /* B0 = 0.348526 */
10458 13397, /* A1 = -0.817688 */
10459 -32615, /* A2 = 0.995361 */
10460 9454, /* B2 = 0.288528 */
10461 -3981, /* B1 = -0.243027 */
10462 9454, /* B0 = 0.288528 */
10463 5, /* Internal filter scaling */
10464 159, /* Minimum in-band energy threshold */
10465 21, /* 21/32 in-band to broad-band ratio */
10466 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10467 },
10468 { /* f1600 */
10469 10046, /* A1 = -0.613190 */
10470 -32331, /* A2 = 0.986694 */
10471 -455, /* B2 = -0.013915 */
10472 0, /* B1 = 0.000000 */
10473 455, /* B0 = 0.013915 */
10474 9694, /* A1 = -0.591705 */
10475 -32601, /* A2 = 0.994934 */
10476 6023, /* B2 = 0.183815 */
10477 -1708, /* B1 = -0.104279 */
10478 6023, /* B0 = 0.183815 */
10479 10478, /* A1 = -0.639587 */
10480 -32603, /* A2 = 0.994965 */
10481 22031, /* B2 = 0.672333 */
10482 -7342, /* B1 = -0.448151 */
10483 22031, /* B0 = 0.672333 */
10484 5, /* Internal filter scaling */
10485 159, /* Minimum in-band energy threshold */
10486 21, /* 21/32 in-band to broad-band ratio */
10487 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10488 },
10489 { /* f1633_1638[] */
10490 9181, /* A1 = 0.560394 */
10491 -32256, /* A2 = -0.984375 */
10492 -556, /* B2 = -0.016975 */
10493 0, /* B1 = 0 */
10494 556, /* B0 = 0.016975 */
10495 8757, /* A1 = 0.534515 */
10496 -32574, /* A2 = -0.99408 */
10497 8443, /* B2 = 0.25769 */
10498 -2135, /* B1 = -0.130341 */
10499 8443, /* B0 = 0.25769 */
10500 9691, /* A1 = 0.591522 */
10501 -32574, /* A2 = -0.99411 */
10502 15446, /* B2 = 0.471375 */
10503 -4809, /* B1 = -0.293579 */
10504 15446, /* B0 = 0.471375 */
10505 7, /* Internal filter scaling */
10506 159, /* Minimum in-band energy threshold */
10507 21, /* 21/32 in-band to broad-band ratio */
10508 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10509 },
10510 { /* f1800 */
10511 5076, /* A1 = -0.309875 */
10512 -32304, /* A2 = 0.985840 */
10513 -508, /* B2 = -0.015503 */
10514 0, /* B1 = 0.000000 */
10515 508, /* B0 = 0.015503 */
10516 4646, /* A1 = -0.283600 */
10517 -32605, /* A2 = 0.995026 */
10518 6742, /* B2 = 0.205780 */
10519 -878, /* B1 = -0.053635 */
10520 6742, /* B0 = 0.205780 */
10521 5552, /* A1 = -0.338928 */
10522 -32605, /* A2 = 0.995056 */
10523 23667, /* B2 = 0.722260 */
10524 -4297, /* B1 = -0.262329 */
10525 23667, /* B0 = 0.722260 */
10526 5, /* Internal filter scaling */
10527 159, /* Minimum in-band energy threshold */
10528 21, /* 21/32 in-band to broad-band ratio */
10529 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10530 },
10531 { /* f1860 */
10532 3569, /* A1 = -0.217865 */
10533 -32292, /* A2 = 0.985504 */
10534 -239, /* B2 = -0.007322 */
10535 0, /* B1 = 0.000000 */
10536 239, /* B0 = 0.007322 */
10537 3117, /* A1 = -0.190277 */
10538 -32603, /* A2 = 0.994965 */
10539 18658, /* B2 = 0.569427 */
10540 -1557, /* B1 = -0.095032 */
10541 18658, /* B0 = 0.569427 */
10542 4054, /* A1 = -0.247437 */
10543 -32603, /* A2 = 0.994965 */
10544 18886, /* B2 = 0.576385 */
10545 -2566, /* B1 = -0.156647 */
10546 18886, /* B0 = 0.576385 */
10547 5, /* Internal filter scaling */
10548 159, /* Minimum in-band energy threshold */
10549 21, /* 21/32 in-band to broad-band ratio */
10550 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10551 },
10552 };
10553 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10554 {
10555 unsigned short cmd;
10556 int cnt, max;
10557
10558 if (jf->filter > 3) {
10559 return -1;
10560 }
10561 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10562
10563 return -1;
10564 if (!jf->enable) {
10565 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10566
10567 return -1;
10568 else
10569 return 0;
10570 } else {
10571 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10572
10573 return -1;
10574 /* Select the filter (f0 - f3) to use. */
10575 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10576 return -1;
10577 }
10578 if (jf->freq < 12 && jf->freq > 3) {
10579 /* Select the frequency for the selected filter. */
10580 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10581 return -1;
10582 } else if (jf->freq > 11) {
10583 /* We need to load a programmable filter set for undefined */
10584 /* frequencies. So we will point the filter to a programmable set. */
10585 /* Since there are only 4 filters and 4 programmable sets, we will */
10586 /* just point the filter to the same number set and program it for the */
10587 /* frequency we want. */
10588 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10589 return -1;
10590 if (j->ver.low != 0x12) {
10591 cmd = 0x515B;
10592 max = 19;
10593 } else {
10594 cmd = 0x515E;
10595 max = 15;
10596 }
10597 if (ixj_WriteDSPCommand(cmd, j))
10598 return -1;
10599 for (cnt = 0; cnt < max; cnt++) {
10600 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10601 return -1;
10602 }
10603 }
10604 j->filter_en[jf->filter] = jf->enable;
10605 return 0;
10606 }
10607
10608 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10609 {
10610 unsigned short cmd;
10611 int cnt, max;
10612 if (jfr->filter > 3) {
10613 return -1;
10614 }
10615 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10616 return -1;
10617
10618 if (!jfr->enable) {
10619 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10620 return -1;
10621 else
10622 return 0;
10623 } else {
10624 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10625 return -1;
10626 /* Select the filter (f0 - f3) to use. */
10627 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10628 return -1;
10629 }
10630 /* We need to load a programmable filter set for undefined */
10631 /* frequencies. So we will point the filter to a programmable set. */
10632 /* Since there are only 4 filters and 4 programmable sets, we will */
10633 /* just point the filter to the same number set and program it for the */
10634 /* frequency we want. */
10635 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10636 return -1;
10637 if (j->ver.low != 0x12) {
10638 cmd = 0x515B;
10639 max = 19;
10640 } else {
10641 cmd = 0x515E;
10642 max = 15;
10643 }
10644 if (ixj_WriteDSPCommand(cmd, j))
10645 return -1;
10646 for (cnt = 0; cnt < max; cnt++) {
10647 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10648 return -1;
10649 }
10650 j->filter_en[jfr->filter] = jfr->enable;
10651 return 0;
10652 }
10653
10654 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10655 {
10656 int freq0, freq1;
10657 unsigned short data;
10658 if (ti->freq0) {
10659 freq0 = ti->freq0;
10660 } else {
10661 freq0 = 0x7FFF;
10662 }
10663
10664 if (ti->freq1) {
10665 freq1 = ti->freq1;
10666 } else {
10667 freq1 = 0x7FFF;
10668 }
10669
10670 if(ti->tone_index > 12 && ti->tone_index < 28)
10671 {
10672 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10673 return -1;
10674 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10675 return -1;
10676 data = freq0;
10677 if (ixj_WriteDSPCommand(data, j))
10678 return -1;
10679 data = freq1;
10680 if (ixj_WriteDSPCommand(data, j))
10681 return -1;
10682 }
10683 return freq0;
10684 }
10685
10686