?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ALSA] version 1.0.11rc2
[linux-2.6/linux-loongson.git] / drivers / telephony / ixj.c
blobf6704688ee8c2e15efb500ce0ed807030e078280
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * $Log: ixj.c,v $
46 *
47 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
48 * Audit some copy_*_user and minor cleanup.
49 *
50 * Revision 4.7 2001/08/13 06:19:33 craigs
51 * Added additional changes from Alan Cox and John Anderson for
52 * 2.2 to 2.4 cleanup and bounds checking
53 *
54 * Revision 4.6 2001/08/13 01:05:05 craigs
55 * Really fixed PHONE_QUERY_CODEC problem this time
56 *
57 * Revision 4.5 2001/08/13 00:11:03 craigs
58 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
59 *
60 * Revision 4.4 2001/08/07 07:58:12 craigs
61 * Changed back to three digit version numbers
62 * Added tagbuild target to allow automatic and easy tagging of versions
63 *
64 * Revision 4.3 2001/08/07 07:24:47 craigs
65 * Added ixj-ver.h to allow easy configuration management of driver
66 * Added display of version number in /prox/ixj
67 *
68 * Revision 4.2 2001/08/06 07:07:19 craigs
69 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
70 * behaviour of returning int rather than short *
71 *
72 * Revision 4.1 2001/08/05 00:17:37 craigs
73 * More changes for correct PCMCIA installation
74 * Start of changes for backward Linux compatibility
75 *
76 * Revision 4.0 2001/08/04 12:33:12 craigs
77 * New version using GNU autoconf
78 *
79 * Revision 3.105 2001/07/20 23:14:32 eokerson
80 * More work on CallerID generation when using ring cadences.
81 *
82 * Revision 3.104 2001/07/06 01:33:55 eokerson
83 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
84 *
85 * Revision 3.103 2001/07/05 19:20:16 eokerson
86 * Updated HOWTO
87 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
88 *
89 * Revision 3.102 2001/07/03 23:51:21 eokerson
90 * Un-mute mic on Internet LineJACK when in speakerphone mode.
91 *
92 * Revision 3.101 2001/07/02 19:26:56 eokerson
93 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
94 *
95 * Revision 3.100 2001/07/02 19:18:27 eokerson
96 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
97 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
98 * Fixed speaker mode on Internet LineJACK.
99 *
100 * Revision 3.99 2001/05/09 14:11:16 eokerson
101 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
102 *
103 * Revision 3.98 2001/05/08 19:55:33 eokerson
104 * Fixed POTS hookstate detection while it is connected to PSTN port.
105 *
106 * Revision 3.97 2001/05/08 00:01:04 eokerson
107 * Fixed kernel oops when sending caller ID data.
108 *
109 * Revision 3.96 2001/05/04 23:09:30 eokerson
110 * Now uses one kernel timer for each card, instead of one for the entire driver.
111 *
112 * Revision 3.95 2001/04/25 22:06:47 eokerson
113 * Fixed squawking at beginning of some G.723.1 calls.
114 *
115 * Revision 3.94 2001/04/03 23:42:00 eokerson
116 * Added linear volume ioctls
117 * Added raw filter load ioctl
118 *
119 * Revision 3.93 2001/02/27 01:00:06 eokerson
120 * Fixed blocking in CallerID.
121 * Reduced size of ixj structure for smaller driver footprint.
122 *
123 * Revision 3.92 2001/02/20 22:02:59 eokerson
124 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
125 * Improved PSTN ring detection.
126 * Fixed wink generation on POTS ports.
127 *
128 * Revision 3.91 2001/02/13 00:55:44 eokerson
129 * Turn AEC back on after changing frame sizes.
130 *
131 * Revision 3.90 2001/02/12 16:42:00 eokerson
132 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
133 *
134 * Revision 3.89 2001/02/12 15:41:16 eokerson
135 * Fix from Artis Kugevics - Tone gains were not being set correctly.
136 *
137 * Revision 3.88 2001/02/05 23:25:42 eokerson
138 * Fixed lockup bugs with deregister.
139 *
140 * Revision 3.87 2001/01/29 21:00:39 eokerson
141 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
142 * Updated copyright date.
143 *
144 * Revision 3.86 2001/01/23 23:53:46 eokerson
145 * Fixes to G.729 compatibility.
146 *
147 * Revision 3.85 2001/01/23 21:30:36 eokerson
148 * Added verbage about cards supported.
149 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
150 *
151 * Revision 3.84 2001/01/22 23:32:10 eokerson
152 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
153 *
154 * Revision 3.83 2001/01/19 14:51:41 eokerson
155 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
156 *
157 * Revision 3.82 2001/01/19 00:34:49 eokerson
158 * Added verbosity to write overlap errors.
159 *
160 * Revision 3.81 2001/01/18 23:56:54 eokerson
161 * Fixed PSTN line test functions.
162 *
163 * Revision 3.80 2001/01/18 22:29:27 eokerson
164 * Updated AEC/AGC values for different cards.
165 *
166 * Revision 3.79 2001/01/17 02:58:54 eokerson
167 * Fixed AEC reset after Caller ID.
168 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
169 *
170 * Revision 3.78 2001/01/16 19:43:09 eokerson
171 * Added support for Linux 2.4.x kernels.
172 *
173 * Revision 3.77 2001/01/09 04:00:52 eokerson
174 * Linetest will now test the line, even if it has previously succeded.
175 *
176 * Revision 3.76 2001/01/08 19:27:00 eokerson
177 * Fixed problem with standard cable on Internet PhoneCARD.
178 *
179 * Revision 3.75 2000/12/22 16:52:14 eokerson
180 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
181 *
182 * Revision 3.74 2000/12/08 22:41:50 eokerson
183 * Added capability for G729B.
184 *
185 * Revision 3.73 2000/12/07 23:35:16 eokerson
186 * Added capability to have different ring pattern before CallerID data.
187 * Added hookstate checks in CallerID routines to stop FSK.
188 *
189 * Revision 3.72 2000/12/06 19:31:31 eokerson
190 * Modified signal behavior to only send one signal per event.
191 *
192 * Revision 3.71 2000/12/06 03:23:08 eokerson
193 * Fixed CallerID on Call Waiting.
194 *
195 * Revision 3.70 2000/12/04 21:29:37 eokerson
196 * Added checking to Smart Cable gain functions.
197 *
198 * Revision 3.69 2000/12/04 21:05:20 eokerson
199 * Changed ixjdebug levels.
200 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
201 *
202 * Revision 3.68 2000/12/04 00:17:21 craigs
203 * Changed mixer voice gain to +6dB rather than 0dB
204 *
205 * Revision 3.67 2000/11/30 21:25:51 eokerson
206 * Fixed write signal errors.
207 *
208 * Revision 3.66 2000/11/29 22:42:44 eokerson
209 * Fixed PSTN ring detect problems.
210 *
211 * Revision 3.65 2000/11/29 07:31:55 craigs
212 * Added new 425Hz filter co-efficients
213 * Added card-specific DTMF prescaler initialisation
214 *
215 * Revision 3.64 2000/11/28 14:03:32 craigs
216 * Changed certain mixer initialisations to be 0dB rather than 12dB
217 * Added additional information to /proc/ixj
218 *
219 * Revision 3.63 2000/11/28 11:38:41 craigs
220 * Added display of AEC modes in AUTO and AGC mode
221 *
222 * Revision 3.62 2000/11/28 04:05:44 eokerson
223 * Improved PSTN ring detection routine.
224 *
225 * Revision 3.61 2000/11/27 21:53:12 eokerson
226 * Fixed flash detection.
227 *
228 * Revision 3.60 2000/11/27 15:57:29 eokerson
229 * More work on G.729 load routines.
230 *
231 * Revision 3.59 2000/11/25 21:55:12 eokerson
232 * Fixed errors in G.729 load routine.
233 *
234 * Revision 3.58 2000/11/25 04:08:29 eokerson
235 * Added board locks around G.729 and TS85 load routines.
236 *
237 * Revision 3.57 2000/11/24 05:35:17 craigs
238 * Added ability to retrieve mixer values on LineJACK
239 * Added complete initialisation of all mixer values at startup
240 * Fixed spelling mistake
241 *
242 * Revision 3.56 2000/11/23 02:52:11 robertj
243 * Added cvs change log keyword.
244 * Fixed bug in capabilities list when using G.729 module.
245 *
246 */
247
248 #include "ixj-ver.h"
249
250 #define PERFMON_STATS
251 #define IXJDEBUG 0
252 #define MAXRINGS 5
253
254 #include <linux/module.h>
255
256 #include <linux/init.h>
257 #include <linux/sched.h>
258 #include <linux/kernel.h> /* printk() */
259 #include <linux/fs.h> /* everything... */
260 #include <linux/errno.h> /* error codes */
261 #include <linux/slab.h>
262 #include <linux/mm.h>
263 #include <linux/ioport.h>
264 #include <linux/interrupt.h>
265 #include <linux/proc_fs.h>
266 #include <linux/poll.h>
267 #include <linux/timer.h>
268 #include <linux/delay.h>
269 #include <linux/pci.h>
270
271 #include <asm/io.h>
272 #include <asm/uaccess.h>
273
274 #include <linux/isapnp.h>
275
276 #include "ixj.h"
277
278 #define TYPE(inode) (iminor(inode) >> 4)
279 #define NUM(inode) (iminor(inode) & 0xf)
280
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 module_param(ixjdebug, int, 0);
286
287 /************************************************************************
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 kfree(j->fskdata);
333 j->fskdata = NULL;
334 }
335
336 static void ixj_fsk_alloc(IXJ *j)
337 {
338 if(!j->fskdata) {
339 j->fskdata = kmalloc(8000, GFP_KERNEL);
340 if (!j->fskdata) {
341 if(ixjdebug & 0x0200) {
342 printk("IXJ phone%d - allocate failed\n", j->board);
343 }
344 return;
345 } else {
346 j->fsksize = 8000;
347 if(ixjdebug & 0x0200) {
348 printk("IXJ phone%d - allocate succeded\n", j->board);
349 }
350 }
351 }
352 }
353
354 #else
355
356 static IXJ ixj[IXJMAX];
357 #define get_ixj(b) (&ixj[(b)])
358
359 /*
360 * Allocate a free IXJ device
361 */
362
363 static IXJ *ixj_alloc(void)
364 {
365 int cnt;
366 for(cnt=0; cnt<IXJMAX; cnt++) {
367 if(!ixj[cnt].DSPbase)
368 return &ixj[cnt];
369 }
370 return NULL;
371 }
372
373 static inline void ixj_fsk_free(IXJ *j) {;}
374
375 static inline void ixj_fsk_alloc(IXJ *j)
376 {
377 j->fsksize = 8000;
378 }
379
380 #endif
381
382 #ifdef PERFMON_STATS
383 #define ixj_perfmon(x) ((x)++)
384 #else
385 #define ixj_perfmon(x) do { } while(0)
386 #endif
387
388 static int ixj_convert_loaded;
389
390 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
391
392 /************************************************************************
393 *
394 * These are function definitions to allow external modules to register
395 * enhanced functionality call backs.
396 *
397 ************************************************************************/
398
399 static int Stub(IXJ * J, unsigned long arg)
400 {
401 return 0;
402 }
403
404 static IXJ_REGFUNC ixj_PreRead = &Stub;
405 static IXJ_REGFUNC ixj_PostRead = &Stub;
406 static IXJ_REGFUNC ixj_PreWrite = &Stub;
407 static IXJ_REGFUNC ixj_PostWrite = &Stub;
408
409 static void ixj_read_frame(IXJ *j);
410 static void ixj_write_frame(IXJ *j);
411 static void ixj_init_timer(IXJ *j);
412 static void ixj_add_timer(IXJ * j);
413 static void ixj_timeout(unsigned long ptr);
414 static int read_filters(IXJ *j);
415 static int LineMonitor(IXJ *j);
416 static int ixj_fasync(int fd, struct file *, int mode);
417 static int ixj_set_port(IXJ *j, int arg);
418 static int ixj_set_pots(IXJ *j, int arg);
419 static int ixj_hookstate(IXJ *j);
420 static int ixj_record_start(IXJ *j);
421 static void ixj_record_stop(IXJ *j);
422 static void set_rec_volume(IXJ *j, int volume);
423 static int get_rec_volume(IXJ *j);
424 static int set_rec_codec(IXJ *j, int rate);
425 static void ixj_vad(IXJ *j, int arg);
426 static int ixj_play_start(IXJ *j);
427 static void ixj_play_stop(IXJ *j);
428 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
429 static int ixj_set_tone_off(unsigned short, IXJ *j);
430 static int ixj_play_tone(IXJ *j, char tone);
431 static void ixj_aec_start(IXJ *j, int level);
432 static int idle(IXJ *j);
433 static void ixj_ring_on(IXJ *j);
434 static void ixj_ring_off(IXJ *j);
435 static void aec_stop(IXJ *j);
436 static void ixj_ringback(IXJ *j);
437 static void ixj_busytone(IXJ *j);
438 static void ixj_dialtone(IXJ *j);
439 static void ixj_cpt_stop(IXJ *j);
440 static char daa_int_read(IXJ *j);
441 static char daa_CR_read(IXJ *j, int cr);
442 static int daa_set_mode(IXJ *j, int mode);
443 static int ixj_linetest(IXJ *j);
444 static int ixj_daa_write(IXJ *j);
445 static int ixj_daa_cid_read(IXJ *j);
446 static void DAA_Coeff_US(IXJ *j);
447 static void DAA_Coeff_UK(IXJ *j);
448 static void DAA_Coeff_France(IXJ *j);
449 static void DAA_Coeff_Germany(IXJ *j);
450 static void DAA_Coeff_Australia(IXJ *j);
451 static void DAA_Coeff_Japan(IXJ *j);
452 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
453 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
454 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
455 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
456 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
457 /* Serial Control Interface funtions */
458 static int SCI_Control(IXJ *j, int control);
459 static int SCI_Prepare(IXJ *j);
460 static int SCI_WaitHighSCI(IXJ *j);
461 static int SCI_WaitLowSCI(IXJ *j);
462 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
463 static int ixj_PCcontrol_wait(IXJ *j);
464 static void ixj_pre_cid(IXJ *j);
465 static void ixj_write_cid(IXJ *j);
466 static void ixj_write_cid_bit(IXJ *j, int bit);
467 static int set_base_frame(IXJ *j, int size);
468 static int set_play_codec(IXJ *j, int rate);
469 static void set_rec_depth(IXJ *j, int depth);
470 static int ixj_mixer(long val, IXJ *j);
471
472 /************************************************************************
473 CT8020/CT8021 Host Programmers Model
474 Host address Function Access
475 DSPbase +
476 0-1 Aux Software Status Register (reserved) Read Only
477 2-3 Software Status Register Read Only
478 4-5 Aux Software Control Register (reserved) Read Write
479 6-7 Software Control Register Read Write
480 8-9 Hardware Status Register Read Only
481 A-B Hardware Control Register Read Write
482 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
483 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
484 ************************************************************************/
485
486 static inline void ixj_read_HSR(IXJ *j)
487 {
488 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
489 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
490 }
491
492 static inline int IsControlReady(IXJ *j)
493 {
494 ixj_read_HSR(j);
495 return j->hsr.bits.controlrdy ? 1 : 0;
496 }
497
498 static inline int IsPCControlReady(IXJ *j)
499 {
500 j->pccr1.byte = inb_p(j->XILINXbase + 3);
501 return j->pccr1.bits.crr ? 1 : 0;
502 }
503
504 static inline int IsStatusReady(IXJ *j)
505 {
506 ixj_read_HSR(j);
507 return j->hsr.bits.statusrdy ? 1 : 0;
508 }
509
510 static inline int IsRxReady(IXJ *j)
511 {
512 ixj_read_HSR(j);
513 ixj_perfmon(j->rxreadycheck);
514 return j->hsr.bits.rxrdy ? 1 : 0;
515 }
516
517 static inline int IsTxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->txreadycheck);
521 return j->hsr.bits.txrdy ? 1 : 0;
522 }
523
524 static inline void set_play_volume(IXJ *j, int volume)
525 {
526 if (ixjdebug & 0x0002)
527 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
528 ixj_WriteDSPCommand(0xCF02, j);
529 ixj_WriteDSPCommand(volume, j);
530 }
531
532 static int set_play_volume_linear(IXJ *j, int volume)
533 {
534 int newvolume, dspplaymax;
535
536 if (ixjdebug & 0x0002)
537 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
538 if(volume > 100 || volume < 0) {
539 return -1;
540 }
541
542 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
543 switch (j->cardtype) {
544 case QTI_PHONEJACK:
545 dspplaymax = 0x380;
546 break;
547 case QTI_LINEJACK:
548 if(j->port == PORT_PSTN) {
549 dspplaymax = 0x48;
550 } else {
551 dspplaymax = 0x100;
552 }
553 break;
554 case QTI_PHONEJACK_LITE:
555 dspplaymax = 0x380;
556 break;
557 case QTI_PHONEJACK_PCI:
558 dspplaymax = 0x6C;
559 break;
560 case QTI_PHONECARD:
561 dspplaymax = 0x50;
562 break;
563 default:
564 return -1;
565 }
566 newvolume = (dspplaymax * volume) / 100;
567 set_play_volume(j, newvolume);
568 return 0;
569 }
570
571 static inline void set_play_depth(IXJ *j, int depth)
572 {
573 if (depth > 60)
574 depth = 60;
575 if (depth < 0)
576 depth = 0;
577 ixj_WriteDSPCommand(0x5280 + depth, j);
578 }
579
580 static inline int get_play_volume(IXJ *j)
581 {
582 ixj_WriteDSPCommand(0xCF00, j);
583 return j->ssr.high << 8 | j->ssr.low;
584 }
585
586 static int get_play_volume_linear(IXJ *j)
587 {
588 int volume, newvolume, dspplaymax;
589
590 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
591 switch (j->cardtype) {
592 case QTI_PHONEJACK:
593 dspplaymax = 0x380;
594 break;
595 case QTI_LINEJACK:
596 if(j->port == PORT_PSTN) {
597 dspplaymax = 0x48;
598 } else {
599 dspplaymax = 0x100;
600 }
601 break;
602 case QTI_PHONEJACK_LITE:
603 dspplaymax = 0x380;
604 break;
605 case QTI_PHONEJACK_PCI:
606 dspplaymax = 0x6C;
607 break;
608 case QTI_PHONECARD:
609 dspplaymax = 100;
610 break;
611 default:
612 return -1;
613 }
614 volume = get_play_volume(j);
615 newvolume = (volume * 100) / dspplaymax;
616 if(newvolume > 100)
617 newvolume = 100;
618 return newvolume;
619 }
620
621 static inline BYTE SLIC_GetState(IXJ *j)
622 {
623 if (j->cardtype == QTI_PHONECARD) {
624 j->pccr1.byte = 0;
625 j->psccr.bits.dev = 3;
626 j->psccr.bits.rw = 1;
627 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
628 ixj_PCcontrol_wait(j);
629 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
630 ixj_PCcontrol_wait(j);
631 if (j->pslic.bits.powerdown)
632 return PLD_SLIC_STATE_OC;
633 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
634 return PLD_SLIC_STATE_ACTIVE;
635 else
636 return PLD_SLIC_STATE_RINGING;
637 } else {
638 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
639 }
640 return j->pld_slicr.bits.state;
641 }
642
643 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
644 {
645 BOOL fRetVal = FALSE;
646
647 if (j->cardtype == QTI_PHONECARD) {
648 if (j->flags.pcmciasct) {
649 switch (byState) {
650 case PLD_SLIC_STATE_TIPOPEN:
651 case PLD_SLIC_STATE_OC:
652 j->pslic.bits.powerdown = 1;
653 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
654 fRetVal = TRUE;
655 break;
656 case PLD_SLIC_STATE_RINGING:
657 if (j->readers || j->writers) {
658 j->pslic.bits.powerdown = 0;
659 j->pslic.bits.ring0 = 1;
660 j->pslic.bits.ring1 = 0;
661 fRetVal = TRUE;
662 }
663 break;
664 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
665
666 case PLD_SLIC_STATE_STANDBY:
667 case PLD_SLIC_STATE_ACTIVE:
668 if (j->readers || j->writers) {
669 j->pslic.bits.powerdown = 0;
670 } else {
671 j->pslic.bits.powerdown = 1;
672 }
673 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
674 fRetVal = TRUE;
675 break;
676 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
677
678 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
679
680 default:
681 fRetVal = FALSE;
682 break;
683 }
684 j->psccr.bits.dev = 3;
685 j->psccr.bits.rw = 0;
686 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
687 ixj_PCcontrol_wait(j);
688 }
689 } else {
690 /* Set the C1, C2, C3 & B2EN signals. */
691 switch (byState) {
692 case PLD_SLIC_STATE_OC:
693 j->pld_slicw.bits.c1 = 0;
694 j->pld_slicw.bits.c2 = 0;
695 j->pld_slicw.bits.c3 = 0;
696 j->pld_slicw.bits.b2en = 0;
697 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
698 fRetVal = TRUE;
699 break;
700 case PLD_SLIC_STATE_RINGING:
701 j->pld_slicw.bits.c1 = 1;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 1;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
706 fRetVal = TRUE;
707 break;
708 case PLD_SLIC_STATE_ACTIVE:
709 j->pld_slicw.bits.c1 = 0;
710 j->pld_slicw.bits.c2 = 1;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 0;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
714 fRetVal = TRUE;
715 break;
716 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
717
718 j->pld_slicw.bits.c1 = 1;
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_TIPOPEN:
726 j->pld_slicw.bits.c1 = 0;
727 j->pld_slicw.bits.c2 = 0;
728 j->pld_slicw.bits.c3 = 1;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
731 fRetVal = TRUE;
732 break;
733 case PLD_SLIC_STATE_STANDBY:
734 j->pld_slicw.bits.c1 = 1;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 1;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
739 fRetVal = TRUE;
740 break;
741 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
742
743 j->pld_slicw.bits.c1 = 0;
744 j->pld_slicw.bits.c2 = 1;
745 j->pld_slicw.bits.c3 = 1;
746 j->pld_slicw.bits.b2en = 0;
747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
748 fRetVal = TRUE;
749 break;
750 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
751
752 j->pld_slicw.bits.c1 = 1;
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 default:
760 fRetVal = FALSE;
761 break;
762 }
763 }
764
765 return fRetVal;
766 }
767
768 static int ixj_wink(IXJ *j)
769 {
770 BYTE slicnow;
771
772 slicnow = SLIC_GetState(j);
773
774 j->pots_winkstart = jiffies;
775 SLIC_SetState(PLD_SLIC_STATE_OC, j);
776
777 msleep(jiffies_to_msecs(j->winktime));
778
779 SLIC_SetState(slicnow, j);
780 return 0;
781 }
782
783 static void ixj_init_timer(IXJ *j)
784 {
785 init_timer(&j->timer);
786 j->timer.function = ixj_timeout;
787 j->timer.data = (unsigned long)j;
788 }
789
790 static void ixj_add_timer(IXJ *j)
791 {
792 j->timer.expires = jiffies + (hertz / samplerate);
793 add_timer(&j->timer);
794 }
795
796 static void ixj_tone_timeout(IXJ *j)
797 {
798 IXJ_TONE ti;
799
800 j->tone_state++;
801 if (j->tone_state == 3) {
802 j->tone_state = 0;
803 if (j->cadence_t) {
804 j->tone_cadence_state++;
805 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
806 switch (j->cadence_t->termination) {
807 case PLAY_ONCE:
808 ixj_cpt_stop(j);
809 break;
810 case REPEAT_LAST_ELEMENT:
811 j->tone_cadence_state--;
812 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
813 break;
814 case REPEAT_ALL:
815 j->tone_cadence_state = 0;
816 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
817 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
818 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
819 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
820 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
821 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
822 ixj_init_tone(j, &ti);
823 }
824 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
825 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
826 ixj_play_tone(j, j->cadence_t->ce[0].index);
827 break;
828 }
829 } else {
830 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
831 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
832 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
833 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
834 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
835 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
836 ixj_init_tone(j, &ti);
837 }
838 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
839 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
840 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
841 }
842 }
843 }
844 }
845
846 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
847 {
848 if(j->ixj_signals[event]) {
849 if(ixjdebug & 0x0100)
850 printk("Sending signal for event %d\n", event);
851 /* Send apps notice of change */
852 /* see config.h for macro definition */
853 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
854 }
855 }
856
857 static void ixj_pstn_state(IXJ *j)
858 {
859 int var;
860 union XOPXR0 XR0, daaint;
861
862 var = 10;
863
864 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
865 daaint.reg = 0;
866 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
867
868 j->pld_scrr.byte = inb_p(j->XILINXbase);
869 if (j->pld_scrr.bits.daaflag) {
870 daa_int_read(j);
871 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
872 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
873 daaint.bitreg.RING = 1;
874 if(ixjdebug & 0x0008) {
875 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
876 }
877 } else {
878 daa_set_mode(j, SOP_PU_RESET);
879 }
880 }
881 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
882 daaint.bitreg.Caller_ID = 1;
883 j->pstn_cid_intr = 1;
884 j->pstn_cid_received = jiffies;
885 if(ixjdebug & 0x0008) {
886 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
890 daaint.bitreg.Cadence = 1;
891 if(ixjdebug & 0x0008) {
892 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
893 }
894 }
895 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
896 daaint.bitreg.VDD_OK = 1;
897 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
898 }
899 }
900 daa_CR_read(j, 1);
901 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)) {
902 daaint.bitreg.RMR = 1;
903 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
904 if(ixjdebug & 0x0008) {
905 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);
906 }
907 j->pstn_prev_rmr = j->pstn_last_rmr;
908 j->pstn_last_rmr = jiffies;
909 }
910 switch(j->daa_mode) {
911 case SOP_PU_SLEEP:
912 if (daaint.bitreg.RING) {
913 if (!j->flags.pstn_ringing) {
914 if (j->daa_mode != SOP_PU_RINGING) {
915 j->pstn_ring_int = jiffies;
916 daa_set_mode(j, SOP_PU_RINGING);
917 }
918 }
919 }
920 break;
921 case SOP_PU_RINGING:
922 if (daaint.bitreg.RMR) {
923 if (ixjdebug & 0x0008) {
924 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
925 }
926 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
927 j->flags.pstn_rmr = 1;
928 j->pstn_ring_start = jiffies;
929 j->pstn_ring_stop = 0;
930 j->ex.bits.pstn_ring = 0;
931 if (j->cadence_f[4].state == 0) {
932 j->cadence_f[4].state = 1;
933 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
934 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
935 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
936 } else if (j->cadence_f[4].state == 2) {
937 if((time_after(jiffies, j->cadence_f[4].off1min) &&
938 time_before(jiffies, j->cadence_f[4].off1max))) {
939 if (j->cadence_f[4].on2) {
940 j->cadence_f[4].state = 3;
941 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
942 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
943 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
944 } else {
945 j->cadence_f[4].state = 7;
946 }
947 } else {
948 if (ixjdebug & 0x0008) {
949 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
950 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
951 j->cadence_f[4].off1);
952 }
953 j->cadence_f[4].state = 0;
954 }
955 } else if (j->cadence_f[4].state == 4) {
956 if((time_after(jiffies, j->cadence_f[4].off2min) &&
957 time_before(jiffies, j->cadence_f[4].off2max))) {
958 if (j->cadence_f[4].on3) {
959 j->cadence_f[4].state = 5;
960 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
961 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
962 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
963 } else {
964 j->cadence_f[4].state = 7;
965 }
966 } else {
967 if (ixjdebug & 0x0008) {
968 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
969 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
970 j->cadence_f[4].off2);
971 }
972 j->cadence_f[4].state = 0;
973 }
974 } else if (j->cadence_f[4].state == 6) {
975 if((time_after(jiffies, j->cadence_f[4].off3min) &&
976 time_before(jiffies, j->cadence_f[4].off3max))) {
977 j->cadence_f[4].state = 7;
978 } else {
979 if (ixjdebug & 0x0008) {
980 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
981 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
982 j->cadence_f[4].off3);
983 }
984 j->cadence_f[4].state = 0;
985 }
986 } else {
987 j->cadence_f[4].state = 0;
988 }
989 } else { /* Falling edge of RMR */
990 j->pstn_ring_start = 0;
991 j->pstn_ring_stop = jiffies;
992 if (j->cadence_f[4].state == 1) {
993 if(!j->cadence_f[4].on1) {
994 j->cadence_f[4].state = 7;
995 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
996 time_before(jiffies, j->cadence_f[4].on1max))) {
997 if (j->cadence_f[4].off1) {
998 j->cadence_f[4].state = 2;
999 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1000 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1001 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1002 } else {
1003 j->cadence_f[4].state = 7;
1004 }
1005 } else {
1006 if (ixjdebug & 0x0008) {
1007 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1008 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1009 j->cadence_f[4].on1);
1010 }
1011 j->cadence_f[4].state = 0;
1012 }
1013 } else if (j->cadence_f[4].state == 3) {
1014 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1015 time_before(jiffies, j->cadence_f[4].on2max))) {
1016 if (j->cadence_f[4].off2) {
1017 j->cadence_f[4].state = 4;
1018 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1019 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1020 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1021 } else {
1022 j->cadence_f[4].state = 7;
1023 }
1024 } else {
1025 if (ixjdebug & 0x0008) {
1026 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1027 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1028 j->cadence_f[4].on2);
1029 }
1030 j->cadence_f[4].state = 0;
1031 }
1032 } else if (j->cadence_f[4].state == 5) {
1033 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1034 time_before(jiffies, j->cadence_f[4].on3max))) {
1035 if (j->cadence_f[4].off3) {
1036 j->cadence_f[4].state = 6;
1037 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1038 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1039 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1040 } else {
1041 j->cadence_f[4].state = 7;
1042 }
1043 } else {
1044 j->cadence_f[4].state = 0;
1045 }
1046 } else {
1047 if (ixjdebug & 0x0008) {
1048 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1049 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1050 j->cadence_f[4].on3);
1051 }
1052 j->cadence_f[4].state = 0;
1053 }
1054 }
1055 if (ixjdebug & 0x0010) {
1056 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1057 }
1058 if (ixjdebug & 0x0010) {
1059 switch(j->cadence_f[4].state) {
1060 case 1:
1061 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1062 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1063 break;
1064 case 2:
1065 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1066 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1067 break;
1068 case 3:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1071 break;
1072 case 4:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1075 break;
1076 case 5:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1079 break;
1080 case 6:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1083 break;
1084 }
1085 }
1086 }
1087 if (j->cadence_f[4].state == 7) {
1088 j->cadence_f[4].state = 0;
1089 j->pstn_ring_stop = jiffies;
1090 j->ex.bits.pstn_ring = 1;
1091 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1092 if(ixjdebug & 0x0008) {
1093 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1094 }
1095 }
1096 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1097 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1098 if(ixjdebug & 0x0008) {
1099 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1100 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1101 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1102 }
1103 j->pstn_ring_stop = j->pstn_ring_int = 0;
1104 daa_set_mode(j, SOP_PU_SLEEP);
1105 }
1106 outb_p(j->pld_scrw.byte, j->XILINXbase);
1107 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1108 ixj_daa_cid_read(j);
1109 j->ex.bits.caller_id = 1;
1110 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1111 j->pstn_cid_intr = 0;
1112 }
1113 if (daaint.bitreg.Cadence) {
1114 if(ixjdebug & 0x0008) {
1115 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1116 }
1117 daa_set_mode(j, SOP_PU_SLEEP);
1118 j->ex.bits.pstn_ring = 0;
1119 }
1120 break;
1121 case SOP_PU_CONVERSATION:
1122 if (daaint.bitreg.VDD_OK) {
1123 if(!daaint.bitreg.SI_0) {
1124 if (!j->pstn_winkstart) {
1125 if(ixjdebug & 0x0008) {
1126 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1127 }
1128 j->pstn_winkstart = jiffies;
1129 }
1130 } else {
1131 if (j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = 0;
1136 }
1137 }
1138 }
1139 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 daa_set_mode(j, SOP_PU_SLEEP);
1144 j->pstn_winkstart = 0;
1145 j->ex.bits.pstn_wink = 1;
1146 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1147 }
1148 break;
1149 }
1150 }
1151
1152 static void ixj_timeout(unsigned long ptr)
1153 {
1154 int board;
1155 unsigned long jifon;
1156 IXJ *j = (IXJ *)ptr;
1157 board = j->board;
1158
1159 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1160 ixj_perfmon(j->timerchecks);
1161 j->hookstate = ixj_hookstate(j);
1162 if (j->tone_state) {
1163 if (!(j->hookstate)) {
1164 ixj_cpt_stop(j);
1165 if (j->m_hook) {
1166 j->m_hook = 0;
1167 j->ex.bits.hookstate = 1;
1168 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1169 }
1170 clear_bit(board, &j->busyflags);
1171 ixj_add_timer(j);
1172 return;
1173 }
1174 if (j->tone_state == 1)
1175 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1176 else
1177 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1178 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1179 if (j->tone_state == 1) {
1180 ixj_play_tone(j, j->tone_index);
1181 if (j->dsp.low == 0x20) {
1182 clear_bit(board, &j->busyflags);
1183 ixj_add_timer(j);
1184 return;
1185 }
1186 } else {
1187 ixj_play_tone(j, 0);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 }
1194 } else {
1195 ixj_tone_timeout(j);
1196 if (j->flags.dialtone) {
1197 ixj_dialtone(j);
1198 }
1199 if (j->flags.busytone) {
1200 ixj_busytone(j);
1201 if (j->dsp.low == 0x20) {
1202 clear_bit(board, &j->busyflags);
1203 ixj_add_timer(j);
1204 return;
1205 }
1206 }
1207 if (j->flags.ringback) {
1208 ixj_ringback(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (!j->tone_state) {
1216 ixj_cpt_stop(j);
1217 }
1218 }
1219 }
1220 if (!(j->tone_state && j->dsp.low == 0x20)) {
1221 if (IsRxReady(j)) {
1222 ixj_read_frame(j);
1223 }
1224 if (IsTxReady(j)) {
1225 ixj_write_frame(j);
1226 }
1227 }
1228 if (j->flags.cringing) {
1229 if (j->hookstate & 1) {
1230 j->flags.cringing = 0;
1231 ixj_ring_off(j);
1232 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1233 switch(j->cadence_f[5].state) {
1234 case 0:
1235 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1236 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1237 if(ixjdebug & 0x0004) {
1238 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1239 }
1240 ixj_ring_on(j);
1241 }
1242 j->cadence_f[5].state = 1;
1243 break;
1244 case 1:
1245 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1246 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1247 if(ixjdebug & 0x0004) {
1248 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1249 }
1250 ixj_ring_off(j);
1251 j->cadence_f[5].state = 2;
1252 }
1253 break;
1254 case 2:
1255 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1256 if(ixjdebug & 0x0004) {
1257 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1258 }
1259 ixj_ring_on(j);
1260 if (j->cadence_f[5].on2) {
1261 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1262 j->cadence_f[5].state = 3;
1263 } else {
1264 j->cadence_f[5].state = 7;
1265 }
1266 }
1267 break;
1268 case 3:
1269 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1270 if(ixjdebug & 0x0004) {
1271 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1272 }
1273 ixj_ring_off(j);
1274 if (j->cadence_f[5].off2) {
1275 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1276 j->cadence_f[5].state = 4;
1277 } else {
1278 j->cadence_f[5].state = 7;
1279 }
1280 }
1281 break;
1282 case 4:
1283 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1284 if(ixjdebug & 0x0004) {
1285 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1286 }
1287 ixj_ring_on(j);
1288 if (j->cadence_f[5].on3) {
1289 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1290 j->cadence_f[5].state = 5;
1291 } else {
1292 j->cadence_f[5].state = 7;
1293 }
1294 }
1295 break;
1296 case 5:
1297 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1298 if(ixjdebug & 0x0004) {
1299 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1300 }
1301 ixj_ring_off(j);
1302 if (j->cadence_f[5].off3) {
1303 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1304 j->cadence_f[5].state = 6;
1305 } else {
1306 j->cadence_f[5].state = 7;
1307 }
1308 }
1309 break;
1310 case 6:
1311 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1312 if(ixjdebug & 0x0004) {
1313 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1314 }
1315 j->cadence_f[5].state = 7;
1316 }
1317 break;
1318 case 7:
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->flags.cidring = 1;
1323 j->cadence_f[5].state = 0;
1324 break;
1325 }
1326 if (j->flags.cidring && !j->flags.cidsent) {
1327 j->flags.cidsent = 1;
1328 if(j->fskdcnt) {
1329 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1330 ixj_pre_cid(j);
1331 }
1332 j->flags.cidring = 0;
1333 }
1334 clear_bit(board, &j->busyflags);
1335 ixj_add_timer(j);
1336 return;
1337 } else {
1338 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1339 if (j->flags.cidring && !j->flags.cidsent) {
1340 j->flags.cidsent = 1;
1341 if(j->fskdcnt) {
1342 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1343 ixj_pre_cid(j);
1344 }
1345 j->flags.cidring = 0;
1346 }
1347 j->ring_cadence_t--;
1348 if (j->ring_cadence_t == -1)
1349 j->ring_cadence_t = 15;
1350 j->ring_cadence_jif = jiffies;
1351
1352 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1353 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1354 j->flags.firstring = 1;
1355 else
1356 ixj_ring_on(j);
1357 } else {
1358 ixj_ring_off(j);
1359 if(!j->flags.cidsent)
1360 j->flags.cidring = 1;
1361 }
1362 }
1363 clear_bit(board, &j->busyflags);
1364 ixj_add_timer(j);
1365 return;
1366 }
1367 }
1368 if (!j->flags.ringing) {
1369 if (j->hookstate) { /* & 1) { */
1370 if (j->dsp.low != 0x20 &&
1371 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1372 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1373 }
1374 LineMonitor(j);
1375 read_filters(j);
1376 ixj_WriteDSPCommand(0x511B, j);
1377 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1378 if (!j->m_hook && (j->hookstate & 1)) {
1379 j->m_hook = j->ex.bits.hookstate = 1;
1380 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1381 }
1382 } else {
1383 if (j->ex.bits.dtmf_ready) {
1384 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1385 }
1386 if (j->m_hook) {
1387 j->m_hook = 0;
1388 j->ex.bits.hookstate = 1;
1389 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1390 }
1391 }
1392 }
1393 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1394 ixj_pstn_state(j);
1395 }
1396 if (j->ex.bytes) {
1397 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1398 }
1399 clear_bit(board, &j->busyflags);
1400 }
1401 ixj_add_timer(j);
1402 }
1403
1404 static int ixj_status_wait(IXJ *j)
1405 {
1406 unsigned long jif;
1407
1408 jif = jiffies + ((60 * hertz) / 100);
1409 while (!IsStatusReady(j)) {
1410 ixj_perfmon(j->statuswait);
1411 if (time_after(jiffies, jif)) {
1412 ixj_perfmon(j->statuswaitfail);
1413 return -1;
1414 }
1415 }
1416 return 0;
1417 }
1418
1419 static int ixj_PCcontrol_wait(IXJ *j)
1420 {
1421 unsigned long jif;
1422
1423 jif = jiffies + ((60 * hertz) / 100);
1424 while (!IsPCControlReady(j)) {
1425 ixj_perfmon(j->pcontrolwait);
1426 if (time_after(jiffies, jif)) {
1427 ixj_perfmon(j->pcontrolwaitfail);
1428 return -1;
1429 }
1430 }
1431 return 0;
1432 }
1433
1434 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1435 {
1436 BYTES bytes;
1437 unsigned long jif;
1438
1439 atomic_inc(&j->DSPWrite);
1440 if(atomic_read(&j->DSPWrite) > 1) {
1441 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1442 return -1;
1443 }
1444 bytes.high = (cmd & 0xFF00) >> 8;
1445 bytes.low = cmd & 0x00FF;
1446 jif = jiffies + ((60 * hertz) / 100);
1447 while (!IsControlReady(j)) {
1448 ixj_perfmon(j->iscontrolready);
1449 if (time_after(jiffies, jif)) {
1450 ixj_perfmon(j->iscontrolreadyfail);
1451 atomic_dec(&j->DSPWrite);
1452 if(atomic_read(&j->DSPWrite) > 0) {
1453 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1454 while(atomic_read(&j->DSPWrite) > 0) {
1455 atomic_dec(&j->DSPWrite);
1456 }
1457 }
1458 return -1;
1459 }
1460 }
1461 outb(bytes.low, j->DSPbase + 6);
1462 outb(bytes.high, j->DSPbase + 7);
1463
1464 if (ixj_status_wait(j)) {
1465 j->ssr.low = 0xFF;
1466 j->ssr.high = 0xFF;
1467 atomic_dec(&j->DSPWrite);
1468 if(atomic_read(&j->DSPWrite) > 0) {
1469 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1470 while(atomic_read(&j->DSPWrite) > 0) {
1471 atomic_dec(&j->DSPWrite);
1472 }
1473 }
1474 return -1;
1475 }
1476 /* Read Software Status Register */
1477 j->ssr.low = inb_p(j->DSPbase + 2);
1478 j->ssr.high = inb_p(j->DSPbase + 3);
1479 atomic_dec(&j->DSPWrite);
1480 if(atomic_read(&j->DSPWrite) > 0) {
1481 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1482 while(atomic_read(&j->DSPWrite) > 0) {
1483 atomic_dec(&j->DSPWrite);
1484 }
1485 }
1486 return 0;
1487 }
1488
1489 /***************************************************************************
1490 *
1491 * General Purpose IO Register read routine
1492 *
1493 ***************************************************************************/
1494 static inline int ixj_gpio_read(IXJ *j)
1495 {
1496 if (ixj_WriteDSPCommand(0x5143, j))
1497 return -1;
1498
1499 j->gpio.bytes.low = j->ssr.low;
1500 j->gpio.bytes.high = j->ssr.high;
1501
1502 return 0;
1503 }
1504
1505 static inline void LED_SetState(int state, IXJ *j)
1506 {
1507 if (j->cardtype == QTI_LINEJACK) {
1508 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1509 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1510 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1511 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1512
1513 outb(j->pld_scrw.byte, j->XILINXbase);
1514 }
1515 }
1516
1517 /*********************************************************************
1518 * GPIO Pins are configured as follows on the Quicknet Internet
1519 * PhoneJACK Telephony Cards
1520 *
1521 * POTS Select GPIO_6=0 GPIO_7=0
1522 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1523 * Handset Select GPIO_6=1 GPIO_7=0
1524 *
1525 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1526 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1527 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1528 *
1529 * Hook Switch changes reported on GPIO_3
1530 *********************************************************************/
1531 static int ixj_set_port(IXJ *j, int arg)
1532 {
1533 if (j->cardtype == QTI_PHONEJACK_LITE) {
1534 if (arg != PORT_POTS)
1535 return 10;
1536 else
1537 return 0;
1538 }
1539 switch (arg) {
1540 case PORT_POTS:
1541 j->port = PORT_POTS;
1542 switch (j->cardtype) {
1543 case QTI_PHONECARD:
1544 if (j->flags.pcmciasct == 1)
1545 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1546 else
1547 return 11;
1548 break;
1549 case QTI_PHONEJACK_PCI:
1550 j->pld_slicw.pcib.mic = 0;
1551 j->pld_slicw.pcib.spk = 0;
1552 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1553 break;
1554 case QTI_LINEJACK:
1555 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1556 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1557 Software Control Register */
1558 return 2;
1559 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1560
1561 outb(j->pld_scrw.byte, j->XILINXbase);
1562 j->pld_clock.byte = 0;
1563 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1564 j->pld_slicw.bits.rly1 = 1;
1565 j->pld_slicw.bits.spken = 0;
1566 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1567 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1568 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1569 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1570 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1571 ixj_mixer(0x0E80, j); /*Mic mute */
1572 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1573 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1574 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1575 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1576 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1577 break;
1578 case QTI_PHONEJACK:
1579 j->gpio.bytes.high = 0x0B;
1580 j->gpio.bits.gpio6 = 0;
1581 j->gpio.bits.gpio7 = 0;
1582 ixj_WriteDSPCommand(j->gpio.word, j);
1583 break;
1584 }
1585 break;
1586 case PORT_PSTN:
1587 if (j->cardtype == QTI_LINEJACK) {
1588 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1589
1590 j->pld_slicw.bits.rly3 = 0;
1591 j->pld_slicw.bits.rly1 = 1;
1592 j->pld_slicw.bits.spken = 0;
1593 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1594 j->port = PORT_PSTN;
1595 } else {
1596 return 4;
1597 }
1598 break;
1599 case PORT_SPEAKER:
1600 j->port = PORT_SPEAKER;
1601 switch (j->cardtype) {
1602 case QTI_PHONECARD:
1603 if (j->flags.pcmciasct) {
1604 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1605 }
1606 break;
1607 case QTI_PHONEJACK_PCI:
1608 j->pld_slicw.pcib.mic = 1;
1609 j->pld_slicw.pcib.spk = 1;
1610 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1611 break;
1612 case QTI_LINEJACK:
1613 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1614 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1615 Software Control Register */
1616 return 2;
1617 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1618
1619 outb(j->pld_scrw.byte, j->XILINXbase);
1620 j->pld_clock.byte = 0;
1621 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1622 j->pld_slicw.bits.rly1 = 1;
1623 j->pld_slicw.bits.spken = 1;
1624 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1625 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1626 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1627 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1628 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1629 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1630 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1631 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1632 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1633 break;
1634 case QTI_PHONEJACK:
1635 j->gpio.bytes.high = 0x0B;
1636 j->gpio.bits.gpio6 = 0;
1637 j->gpio.bits.gpio7 = 1;
1638 ixj_WriteDSPCommand(j->gpio.word, j);
1639 break;
1640 }
1641 break;
1642 case PORT_HANDSET:
1643 if (j->cardtype != QTI_PHONEJACK) {
1644 return 5;
1645 } else {
1646 j->gpio.bytes.high = 0x0B;
1647 j->gpio.bits.gpio6 = 1;
1648 j->gpio.bits.gpio7 = 0;
1649 ixj_WriteDSPCommand(j->gpio.word, j);
1650 j->port = PORT_HANDSET;
1651 }
1652 break;
1653 default:
1654 return 6;
1655 break;
1656 }
1657 return 0;
1658 }
1659
1660 static int ixj_set_pots(IXJ *j, int arg)
1661 {
1662 if (j->cardtype == QTI_LINEJACK) {
1663 if (arg) {
1664 if (j->port == PORT_PSTN) {
1665 j->pld_slicw.bits.rly1 = 0;
1666 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1667 j->flags.pots_pstn = 1;
1668 return 1;
1669 } else {
1670 j->flags.pots_pstn = 0;
1671 return 0;
1672 }
1673 } else {
1674 j->pld_slicw.bits.rly1 = 1;
1675 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1676 j->flags.pots_pstn = 0;
1677 return 1;
1678 }
1679 } else {
1680 return 0;
1681 }
1682 }
1683
1684 static void ixj_ring_on(IXJ *j)
1685 {
1686 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1687 {
1688 if (ixjdebug & 0x0004)
1689 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1690
1691 j->gpio.bytes.high = 0x0B;
1692 j->gpio.bytes.low = 0x00;
1693 j->gpio.bits.gpio1 = 1;
1694 j->gpio.bits.gpio2 = 1;
1695 j->gpio.bits.gpio5 = 0;
1696 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1697 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1698 {
1699 if (ixjdebug & 0x0004)
1700 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1701
1702 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1703 }
1704 }
1705
1706 static int ixj_siadc(IXJ *j, int val)
1707 {
1708 if(j->cardtype == QTI_PHONECARD){
1709 if(j->flags.pcmciascp){
1710 if(val == -1)
1711 return j->siadc.bits.rxg;
1712
1713 if(val < 0 || val > 0x1F)
1714 return -1;
1715
1716 j->siadc.bits.hom = 0; /* Handset Out Mute */
1717 j->siadc.bits.lom = 0; /* Line Out Mute */
1718 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1719 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1720 j->psccr.bits.rw = 0; /* Read / Write flag */
1721 j->psccr.bits.dev = 0;
1722 outb(j->siadc.byte, j->XILINXbase + 0x00);
1723 outb(j->psccr.byte, j->XILINXbase + 0x01);
1724 ixj_PCcontrol_wait(j);
1725 return j->siadc.bits.rxg;
1726 }
1727 }
1728 return -1;
1729 }
1730
1731 static int ixj_sidac(IXJ *j, int val)
1732 {
1733 if(j->cardtype == QTI_PHONECARD){
1734 if(j->flags.pcmciascp){
1735 if(val == -1)
1736 return j->sidac.bits.txg;
1737
1738 if(val < 0 || val > 0x1F)
1739 return -1;
1740
1741 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1742 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1743 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1744 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1745 j->psccr.bits.rw = 0; /* Read / Write flag */
1746 j->psccr.bits.dev = 0;
1747 outb(j->sidac.byte, j->XILINXbase + 0x00);
1748 outb(j->psccr.byte, j->XILINXbase + 0x01);
1749 ixj_PCcontrol_wait(j);
1750 return j->sidac.bits.txg;
1751 }
1752 }
1753 return -1;
1754 }
1755
1756 static int ixj_pcmcia_cable_check(IXJ *j)
1757 {
1758 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1759 if (!j->flags.pcmciastate) {
1760 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1761 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1762 j->flags.pcmciastate = 4;
1763 return 0;
1764 }
1765 if (j->pccr1.bits.ed) {
1766 j->pccr1.bits.ed = 0;
1767 j->psccr.bits.dev = 3;
1768 j->psccr.bits.rw = 1;
1769 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1770 ixj_PCcontrol_wait(j);
1771 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1772 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1773 j->psccr.bits.dev = 3;
1774 j->psccr.bits.rw = 0;
1775 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1776 ixj_PCcontrol_wait(j);
1777 return j->pslic.bits.led2 ? 1 : 0;
1778 } else if (j->flags.pcmciasct) {
1779 return j->r_hook;
1780 } else {
1781 return 1;
1782 }
1783 } else if (j->flags.pcmciastate == 4) {
1784 if (!j->pccr1.bits.drf) {
1785 j->flags.pcmciastate = 3;
1786 }
1787 return 0;
1788 } else if (j->flags.pcmciastate == 3) {
1789 j->pccr2.bits.pwr = 0;
1790 j->pccr2.bits.rstc = 1;
1791 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1792 j->checkwait = jiffies + (hertz * 2);
1793 j->flags.incheck = 1;
1794 j->flags.pcmciastate = 2;
1795 return 0;
1796 } else if (j->flags.pcmciastate == 2) {
1797 if (j->flags.incheck) {
1798 if (time_before(jiffies, j->checkwait)) {
1799 return 0;
1800 } else {
1801 j->flags.incheck = 0;
1802 }
1803 }
1804 j->pccr2.bits.pwr = 0;
1805 j->pccr2.bits.rstc = 0;
1806 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1807 j->flags.pcmciastate = 1;
1808 return 0;
1809 } else if (j->flags.pcmciastate == 1) {
1810 j->flags.pcmciastate = 0;
1811 if (!j->pccr1.bits.drf) {
1812 j->psccr.bits.dev = 3;
1813 j->psccr.bits.rw = 1;
1814 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1815 ixj_PCcontrol_wait(j);
1816 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1817
1818 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1819
1820 if (j->flags.pcmciasct == 3) {
1821 j->flags.pcmciastate = 4;
1822 return 0;
1823 } else if (j->flags.pcmciasct == 0) {
1824 j->pccr2.bits.pwr = 1;
1825 j->pccr2.bits.rstc = 0;
1826 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1827 j->port = PORT_SPEAKER;
1828 } else {
1829 j->port = PORT_POTS;
1830 }
1831 j->sic1.bits.cpd = 0; /* Chip Power Down */
1832 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1833 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1834 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1835 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1836 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1837 j->psccr.bits.rw = 0; /* Read / Write flag */
1838 j->psccr.bits.dev = 0;
1839 outb(j->sic1.byte, j->XILINXbase + 0x00);
1840 outb(j->psccr.byte, j->XILINXbase + 0x01);
1841 ixj_PCcontrol_wait(j);
1842
1843 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1844 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1845 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1846 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1847 j->sic2.bits.hpd = 0; /* HPF disable */
1848 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1849 j->psccr.bits.rw = 0; /* Read / Write flag */
1850 j->psccr.bits.dev = 0;
1851 outb(j->sic2.byte, j->XILINXbase + 0x00);
1852 outb(j->psccr.byte, j->XILINXbase + 0x01);
1853 ixj_PCcontrol_wait(j);
1854
1855 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->sirxg.bits.lig = 1; /* Line In Gain */
1870 j->sirxg.bits.lim = 1; /* Line In Mute */
1871 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1872 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1873 j->sirxg.bits.him = 0; /* Handset In Mute */
1874 j->sirxg.bits.iir = 1; /* IIR */
1875 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1876 j->psccr.bits.rw = 0; /* Read / Write flag */
1877 j->psccr.bits.dev = 0;
1878 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1879 outb(j->psccr.byte, j->XILINXbase + 0x01);
1880 ixj_PCcontrol_wait(j);
1881
1882 ixj_siadc(j, 0x17);
1883 ixj_sidac(j, 0x1D);
1884
1885 j->siaatt.bits.sot = 0;
1886 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1887 j->psccr.bits.rw = 0; /* Read / Write flag */
1888 j->psccr.bits.dev = 0;
1889 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1890 outb(j->psccr.byte, j->XILINXbase + 0x01);
1891 ixj_PCcontrol_wait(j);
1892
1893 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1894 j->psccr.byte = j->pslic.byte = 0;
1895 j->pslic.bits.powerdown = 1;
1896 j->psccr.bits.dev = 3;
1897 j->psccr.bits.rw = 0;
1898 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1899 ixj_PCcontrol_wait(j);
1900 }
1901 }
1902 return 0;
1903 } else {
1904 j->flags.pcmciascp = 0;
1905 return 0;
1906 }
1907 return 0;
1908 }
1909
1910 static int ixj_hookstate(IXJ *j)
1911 {
1912 int fOffHook = 0;
1913
1914 switch (j->cardtype) {
1915 case QTI_PHONEJACK:
1916 ixj_gpio_read(j);
1917 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1918 break;
1919 case QTI_LINEJACK:
1920 case QTI_PHONEJACK_LITE:
1921 case QTI_PHONEJACK_PCI:
1922 SLIC_GetState(j);
1923 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1924 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1925 if(fOffHook != j->p_hook) {
1926 if(!j->checkwait) {
1927 j->checkwait = jiffies;
1928 }
1929 if(time_before(jiffies, j->checkwait + 2)) {
1930 fOffHook ^= 1;
1931 } else {
1932 j->checkwait = 0;
1933 }
1934 j->p_hook = fOffHook;
1935 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1936 }
1937 } else {
1938 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1939 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1940 if (j->flags.ringing || j->flags.cringing) {
1941 if (!in_interrupt()) {
1942 msleep(20);
1943 }
1944 SLIC_GetState(j);
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1946 ixj_ring_on(j);
1947 }
1948 }
1949 if (j->cardtype == QTI_PHONEJACK_PCI) {
1950 j->pld_scrr.byte = inb_p(j->XILINXbase);
1951 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1952 } else
1953 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1954 }
1955 }
1956 break;
1957 case QTI_PHONECARD:
1958 fOffHook = ixj_pcmcia_cable_check(j);
1959 break;
1960 }
1961 if (j->r_hook != fOffHook) {
1962 j->r_hook = fOffHook;
1963 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1964 j->ex.bits.hookstate = 1;
1965 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1966 } else if (!fOffHook) {
1967 j->flash_end = jiffies + ((60 * hertz) / 100);
1968 }
1969 }
1970 if (fOffHook) {
1971 if(time_before(jiffies, j->flash_end)) {
1972 j->ex.bits.flash = 1;
1973 j->flash_end = 0;
1974 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1975 }
1976 } else {
1977 if(time_before(jiffies, j->flash_end)) {
1978 fOffHook = 1;
1979 }
1980 }
1981
1982 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1983 fOffHook |= 2;
1984
1985 if (j->port == PORT_SPEAKER) {
1986 if(j->cardtype == QTI_PHONECARD) {
1987 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1988 fOffHook |= 2;
1989 }
1990 } else {
1991 fOffHook |= 2;
1992 }
1993 }
1994
1995 if (j->port == PORT_HANDSET)
1996 fOffHook |= 2;
1997
1998 return fOffHook;
1999 }
2000
2001 static void ixj_ring_off(IXJ *j)
2002 {
2003 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2004 {
2005 if (ixjdebug & 0x0004)
2006 printk(KERN_INFO "IXJ Ring Off\n");
2007 j->gpio.bytes.high = 0x0B;
2008 j->gpio.bytes.low = 0x00;
2009 j->gpio.bits.gpio1 = 0;
2010 j->gpio.bits.gpio2 = 1;
2011 j->gpio.bits.gpio5 = 0;
2012 ixj_WriteDSPCommand(j->gpio.word, j);
2013 } else /* Internet LineJACK */
2014 {
2015 if (ixjdebug & 0x0004)
2016 printk(KERN_INFO "IXJ Ring Off\n");
2017
2018 if(!j->flags.cidplay)
2019 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2020
2021 SLIC_GetState(j);
2022 }
2023 }
2024
2025 static void ixj_ring_start(IXJ *j)
2026 {
2027 j->flags.cringing = 1;
2028 if (ixjdebug & 0x0004)
2029 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2030 if (ixj_hookstate(j) & 1) {
2031 if (j->port == PORT_POTS)
2032 ixj_ring_off(j);
2033 j->flags.cringing = 0;
2034 if (ixjdebug & 0x0004)
2035 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2036 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2037 j->ring_cadence_jif = jiffies;
2038 j->flags.cidsent = j->flags.cidring = 0;
2039 j->cadence_f[5].state = 0;
2040 if(j->cadence_f[5].on1)
2041 ixj_ring_on(j);
2042 } else {
2043 j->ring_cadence_jif = jiffies;
2044 j->ring_cadence_t = 15;
2045 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2046 ixj_ring_on(j);
2047 } else {
2048 ixj_ring_off(j);
2049 }
2050 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2051 }
2052 }
2053
2054 static int ixj_ring(IXJ *j)
2055 {
2056 char cntr;
2057 unsigned long jif;
2058
2059 j->flags.ringing = 1;
2060 if (ixj_hookstate(j) & 1) {
2061 ixj_ring_off(j);
2062 j->flags.ringing = 0;
2063 return 1;
2064 }
2065 for (cntr = 0; cntr < j->maxrings; cntr++) {
2066 jif = jiffies + (1 * hertz);
2067 ixj_ring_on(j);
2068 while (time_before(jiffies, jif)) {
2069 if (ixj_hookstate(j) & 1) {
2070 ixj_ring_off(j);
2071 j->flags.ringing = 0;
2072 return 1;
2073 }
2074 schedule_timeout_interruptible(1);
2075 if (signal_pending(current))
2076 break;
2077 }
2078 jif = jiffies + (3 * hertz);
2079 ixj_ring_off(j);
2080 while (time_before(jiffies, jif)) {
2081 if (ixj_hookstate(j) & 1) {
2082 msleep(10);
2083 if (ixj_hookstate(j) & 1) {
2084 j->flags.ringing = 0;
2085 return 1;
2086 }
2087 }
2088 schedule_timeout_interruptible(1);
2089 if (signal_pending(current))
2090 break;
2091 }
2092 }
2093 ixj_ring_off(j);
2094 j->flags.ringing = 0;
2095 return 0;
2096 }
2097
2098 static int ixj_open(struct phone_device *p, struct file *file_p)
2099 {
2100 IXJ *j = get_ixj(p->board);
2101 file_p->private_data = j;
2102
2103 if (!j->DSPbase)
2104 return -ENODEV;
2105
2106 if (file_p->f_mode & FMODE_READ) {
2107 if(!j->readers) {
2108 j->readers++;
2109 } else {
2110 return -EBUSY;
2111 }
2112 }
2113
2114 if (file_p->f_mode & FMODE_WRITE) {
2115 if(!j->writers) {
2116 j->writers++;
2117 } else {
2118 if (file_p->f_mode & FMODE_READ){
2119 j->readers--;
2120 }
2121 return -EBUSY;
2122 }
2123 }
2124
2125 if (j->cardtype == QTI_PHONECARD) {
2126 j->pslic.bits.powerdown = 0;
2127 j->psccr.bits.dev = 3;
2128 j->psccr.bits.rw = 0;
2129 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2130 ixj_PCcontrol_wait(j);
2131 }
2132
2133 j->flags.cidplay = 0;
2134 j->flags.cidcw_ack = 0;
2135
2136 if (ixjdebug & 0x0002)
2137 printk(KERN_INFO "Opening board %d\n", p->board);
2138
2139 j->framesread = j->frameswritten = 0;
2140 return 0;
2141 }
2142
2143 static int ixj_release(struct inode *inode, struct file *file_p)
2144 {
2145 IXJ_TONE ti;
2146 int cnt;
2147 IXJ *j = file_p->private_data;
2148 int board = j->p.board;
2149
2150 /*
2151 * Set up locks to ensure that only one process is talking to the DSP at a time.
2152 * This is necessary to keep the DSP from locking up.
2153 */
2154 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2155 schedule_timeout_interruptible(1);
2156 if (ixjdebug & 0x0002)
2157 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2158
2159 if (j->cardtype == QTI_PHONECARD)
2160 ixj_set_port(j, PORT_SPEAKER);
2161 else
2162 ixj_set_port(j, PORT_POTS);
2163
2164 aec_stop(j);
2165 ixj_play_stop(j);
2166 ixj_record_stop(j);
2167 set_play_volume(j, 0x100);
2168 set_rec_volume(j, 0x100);
2169 ixj_ring_off(j);
2170
2171 /* Restore the tone table to default settings. */
2172 ti.tone_index = 10;
2173 ti.gain0 = 1;
2174 ti.freq0 = hz941;
2175 ti.gain1 = 0;
2176 ti.freq1 = hz1209;
2177 ixj_init_tone(j, &ti);
2178 ti.tone_index = 11;
2179 ti.gain0 = 1;
2180 ti.freq0 = hz941;
2181 ti.gain1 = 0;
2182 ti.freq1 = hz1336;
2183 ixj_init_tone(j, &ti);
2184 ti.tone_index = 12;
2185 ti.gain0 = 1;
2186 ti.freq0 = hz941;
2187 ti.gain1 = 0;
2188 ti.freq1 = hz1477;
2189 ixj_init_tone(j, &ti);
2190 ti.tone_index = 13;
2191 ti.gain0 = 1;
2192 ti.freq0 = hz800;
2193 ti.gain1 = 0;
2194 ti.freq1 = 0;
2195 ixj_init_tone(j, &ti);
2196 ti.tone_index = 14;
2197 ti.gain0 = 1;
2198 ti.freq0 = hz1000;
2199 ti.gain1 = 0;
2200 ti.freq1 = 0;
2201 ixj_init_tone(j, &ti);
2202 ti.tone_index = 15;
2203 ti.gain0 = 1;
2204 ti.freq0 = hz1250;
2205 ti.gain1 = 0;
2206 ti.freq1 = 0;
2207 ixj_init_tone(j, &ti);
2208 ti.tone_index = 16;
2209 ti.gain0 = 1;
2210 ti.freq0 = hz950;
2211 ti.gain1 = 0;
2212 ti.freq1 = 0;
2213 ixj_init_tone(j, &ti);
2214 ti.tone_index = 17;
2215 ti.gain0 = 1;
2216 ti.freq0 = hz1100;
2217 ti.gain1 = 0;
2218 ti.freq1 = 0;
2219 ixj_init_tone(j, &ti);
2220 ti.tone_index = 18;
2221 ti.gain0 = 1;
2222 ti.freq0 = hz1400;
2223 ti.gain1 = 0;
2224 ti.freq1 = 0;
2225 ixj_init_tone(j, &ti);
2226 ti.tone_index = 19;
2227 ti.gain0 = 1;
2228 ti.freq0 = hz1500;
2229 ti.gain1 = 0;
2230 ti.freq1 = 0;
2231 ixj_init_tone(j, &ti);
2232 ti.tone_index = 20;
2233 ti.gain0 = 1;
2234 ti.freq0 = hz1600;
2235 ti.gain1 = 0;
2236 ti.freq1 = 0;
2237 ixj_init_tone(j, &ti);
2238 ti.tone_index = 21;
2239 ti.gain0 = 1;
2240 ti.freq0 = hz1800;
2241 ti.gain1 = 0;
2242 ti.freq1 = 0;
2243 ixj_init_tone(j, &ti);
2244 ti.tone_index = 22;
2245 ti.gain0 = 1;
2246 ti.freq0 = hz2100;
2247 ti.gain1 = 0;
2248 ti.freq1 = 0;
2249 ixj_init_tone(j, &ti);
2250 ti.tone_index = 23;
2251 ti.gain0 = 1;
2252 ti.freq0 = hz1300;
2253 ti.gain1 = 0;
2254 ti.freq1 = 0;
2255 ixj_init_tone(j, &ti);
2256 ti.tone_index = 24;
2257 ti.gain0 = 1;
2258 ti.freq0 = hz2450;
2259 ti.gain1 = 0;
2260 ti.freq1 = 0;
2261 ixj_init_tone(j, &ti);
2262 ti.tone_index = 25;
2263 ti.gain0 = 1;
2264 ti.freq0 = hz350;
2265 ti.gain1 = 0;
2266 ti.freq1 = hz440;
2267 ixj_init_tone(j, &ti);
2268 ti.tone_index = 26;
2269 ti.gain0 = 1;
2270 ti.freq0 = hz440;
2271 ti.gain1 = 0;
2272 ti.freq1 = hz480;
2273 ixj_init_tone(j, &ti);
2274 ti.tone_index = 27;
2275 ti.gain0 = 1;
2276 ti.freq0 = hz480;
2277 ti.gain1 = 0;
2278 ti.freq1 = hz620;
2279 ixj_init_tone(j, &ti);
2280
2281 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2282
2283 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2284
2285 j->ex.bits.dtmf_ready = 0;
2286 j->dtmf_state = 0;
2287 j->dtmf_wp = j->dtmf_rp = 0;
2288 j->rec_mode = j->play_mode = -1;
2289 j->flags.ringing = 0;
2290 j->maxrings = MAXRINGS;
2291 j->ring_cadence = USA_RING_CADENCE;
2292 if(j->cadence_f[5].enable) {
2293 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2294 }
2295 j->drybuffer = 0;
2296 j->winktime = 320;
2297 j->flags.dtmf_oob = 0;
2298 for (cnt = 0; cnt < 4; cnt++)
2299 j->cadence_f[cnt].enable = 0;
2300
2301 idle(j);
2302
2303 if(j->cardtype == QTI_PHONECARD) {
2304 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2305 }
2306
2307 if (file_p->f_mode & FMODE_READ)
2308 j->readers--;
2309 if (file_p->f_mode & FMODE_WRITE)
2310 j->writers--;
2311
2312 if (j->read_buffer && !j->readers) {
2313 kfree(j->read_buffer);
2314 j->read_buffer = NULL;
2315 j->read_buffer_size = 0;
2316 }
2317 if (j->write_buffer && !j->writers) {
2318 kfree(j->write_buffer);
2319 j->write_buffer = NULL;
2320 j->write_buffer_size = 0;
2321 }
2322 j->rec_codec = j->play_codec = 0;
2323 j->rec_frame_size = j->play_frame_size = 0;
2324 j->flags.cidsent = j->flags.cidring = 0;
2325 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2326
2327 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2328 ixj_set_port(j, PORT_PSTN);
2329 daa_set_mode(j, SOP_PU_SLEEP);
2330 ixj_set_pots(j, 1);
2331 }
2332 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2333
2334 /* Set up the default signals for events */
2335 for (cnt = 0; cnt < 35; cnt++)
2336 j->ixj_signals[cnt] = SIGIO;
2337
2338 /* Set the excetion signal enable flags */
2339 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2340 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 =
2341 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;
2342
2343 file_p->private_data = NULL;
2344 clear_bit(board, &j->busyflags);
2345 return 0;
2346 }
2347
2348 static int read_filters(IXJ *j)
2349 {
2350 unsigned short fc, cnt, trg;
2351 int var;
2352
2353 trg = 0;
2354 if (ixj_WriteDSPCommand(0x5144, j)) {
2355 if(ixjdebug & 0x0001) {
2356 printk(KERN_INFO "Read Frame Counter failed!\n");
2357 }
2358 return -1;
2359 }
2360 fc = j->ssr.high << 8 | j->ssr.low;
2361 if (fc == j->frame_count)
2362 return 1;
2363
2364 j->frame_count = fc;
2365
2366 if (j->dtmf_proc)
2367 return 1;
2368
2369 var = 10;
2370
2371 for (cnt = 0; cnt < 4; cnt++) {
2372 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2373 if(ixjdebug & 0x0001) {
2374 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2375 }
2376 return -1;
2377 }
2378 if (ixj_WriteDSPCommand(0x515C, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2381 }
2382 return -1;
2383 }
2384 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2385
2386 if (j->cadence_f[cnt].enable) {
2387 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2388 if (j->cadence_f[cnt].state == 0) {
2389 j->cadence_f[cnt].state = 1;
2390 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2391 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2392 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2393 } else if (j->cadence_f[cnt].state == 2 &&
2394 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2395 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2396 if (j->cadence_f[cnt].on2) {
2397 j->cadence_f[cnt].state = 3;
2398 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2399 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2400 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2401 } else {
2402 j->cadence_f[cnt].state = 7;
2403 }
2404 } else if (j->cadence_f[cnt].state == 4 &&
2405 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2406 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2407 if (j->cadence_f[cnt].on3) {
2408 j->cadence_f[cnt].state = 5;
2409 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2410 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2411 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2412 } else {
2413 j->cadence_f[cnt].state = 7;
2414 }
2415 } else {
2416 j->cadence_f[cnt].state = 0;
2417 }
2418 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2419 if (j->cadence_f[cnt].state == 1) {
2420 if(!j->cadence_f[cnt].on1) {
2421 j->cadence_f[cnt].state = 7;
2422 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2423 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2424 if(j->cadence_f[cnt].off1) {
2425 j->cadence_f[cnt].state = 2;
2426 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2427 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2428 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2429 } else {
2430 j->cadence_f[cnt].state = 7;
2431 }
2432 } else {
2433 j->cadence_f[cnt].state = 0;
2434 }
2435 } else if (j->cadence_f[cnt].state == 3) {
2436 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2437 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2438 if(j->cadence_f[cnt].off2) {
2439 j->cadence_f[cnt].state = 4;
2440 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2441 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2442 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2443 } else {
2444 j->cadence_f[cnt].state = 7;
2445 }
2446 } else {
2447 j->cadence_f[cnt].state = 0;
2448 }
2449 } else if (j->cadence_f[cnt].state == 5) {
2450 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2451 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2452 if(j->cadence_f[cnt].off3) {
2453 j->cadence_f[cnt].state = 6;
2454 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2455 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2456 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2457 } else {
2458 j->cadence_f[cnt].state = 7;
2459 }
2460 } else {
2461 j->cadence_f[cnt].state = 0;
2462 }
2463 } else {
2464 j->cadence_f[cnt].state = 0;
2465 }
2466 } else {
2467 switch(j->cadence_f[cnt].state) {
2468 case 1:
2469 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2470 !j->cadence_f[cnt].off1 &&
2471 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2472 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2473 j->cadence_f[cnt].state = 7;
2474 }
2475 break;
2476 case 3:
2477 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2478 !j->cadence_f[cnt].off2 &&
2479 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2480 j->cadence_f[cnt].state = 7;
2481 }
2482 break;
2483 case 5:
2484 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2485 !j->cadence_f[cnt].off3) {
2486 j->cadence_f[cnt].state = 7;
2487 }
2488 break;
2489 }
2490 }
2491
2492 if (ixjdebug & 0x0040) {
2493 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2494 switch(j->cadence_f[cnt].state) {
2495 case 0:
2496 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2497 break;
2498 case 1:
2499 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2500 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2501 break;
2502 case 2:
2503 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2504 j->cadence_f[cnt].off1max);
2505 break;
2506 case 3:
2507 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2508 j->cadence_f[cnt].on2max);
2509 break;
2510 case 4:
2511 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2512 j->cadence_f[cnt].off2max);
2513 break;
2514 case 5:
2515 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2516 j->cadence_f[cnt].on3max);
2517 break;
2518 case 6:
2519 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2520 j->cadence_f[cnt].off3max);
2521 break;
2522 }
2523 }
2524 }
2525 if (j->cadence_f[cnt].state == 7) {
2526 j->cadence_f[cnt].state = 0;
2527 if (j->cadence_f[cnt].enable == 1)
2528 j->cadence_f[cnt].enable = 0;
2529 switch (cnt) {
2530 case 0:
2531 if(ixjdebug & 0x0020) {
2532 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2533 }
2534 j->ex.bits.fc0 = 1;
2535 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2536 break;
2537 case 1:
2538 if(ixjdebug & 0x0020) {
2539 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2540 }
2541 j->ex.bits.fc1 = 1;
2542 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2543 break;
2544 case 2:
2545 if(ixjdebug & 0x0020) {
2546 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2547 }
2548 j->ex.bits.fc2 = 1;
2549 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2550 break;
2551 case 3:
2552 if(ixjdebug & 0x0020) {
2553 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2554 }
2555 j->ex.bits.fc3 = 1;
2556 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2557 break;
2558 }
2559 }
2560 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2561 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2562 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2563 trg = 1;
2564 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2565 trg = 0;
2566 }
2567 switch (cnt) {
2568 case 0:
2569 if(ixjdebug & 0x0020) {
2570 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2571 }
2572 j->ex.bits.f0 = 1;
2573 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2574 break;
2575 case 1:
2576 if(ixjdebug & 0x0020) {
2577 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2578 }
2579 j->ex.bits.f1 = 1;
2580 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2581 break;
2582 case 2:
2583 if(ixjdebug & 0x0020) {
2584 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2585 }
2586 j->ex.bits.f2 = 1;
2587 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2588 break;
2589 case 3:
2590 if(ixjdebug & 0x0020) {
2591 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2592 }
2593 j->ex.bits.f3 = 1;
2594 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2595 break;
2596 }
2597 }
2598 }
2599 return 0;
2600 }
2601
2602 static int LineMonitor(IXJ *j)
2603 {
2604 if (j->dtmf_proc) {
2605 return -1;
2606 }
2607 j->dtmf_proc = 1;
2608
2609 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2610 return -1;
2611
2612 j->dtmf.bytes.high = j->ssr.high;
2613 j->dtmf.bytes.low = j->ssr.low;
2614 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2615 j->dtmf_state = 1;
2616 j->dtmf_current = j->dtmf.bits.digit;
2617 }
2618 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2619 {
2620 if(!j->cidcw_wait) {
2621 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2622 j->dtmf_wp++;
2623 if (j->dtmf_wp == 79)
2624 j->dtmf_wp = 0;
2625 j->ex.bits.dtmf_ready = 1;
2626 if(j->ex_sig.bits.dtmf_ready) {
2627 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2628 }
2629 }
2630 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2631 if(ixjdebug & 0x0020) {
2632 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2633 }
2634 j->flags.cidcw_ack = 1;
2635 }
2636 j->dtmf_state = 0;
2637 }
2638 j->dtmf_proc = 0;
2639
2640 return 0;
2641 }
2642
2643 /************************************************************************
2644 *
2645 * Functions to allow alaw <-> ulaw conversions.
2646 *
2647 ************************************************************************/
2648
2649 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2650 {
2651 static unsigned char table_ulaw2alaw[] =
2652 {
2653 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2654 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2655 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2656 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2657 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2658 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2659 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2660 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2661 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2662 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2663 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2664 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2665 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2666 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2667 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2668 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2669 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2670 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2671 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2672 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2673 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2674 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2675 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2676 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2677 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2678 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2679 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2680 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2681 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2682 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2683 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2684 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2685 };
2686
2687 while (len--)
2688 {
2689 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2690 buff++;
2691 }
2692 }
2693
2694 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2695 {
2696 static unsigned char table_alaw2ulaw[] =
2697 {
2698 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2699 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2700 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2701 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2702 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2703 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2704 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2705 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2706 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2707 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2708 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2709 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2710 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2711 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2712 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2713 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2714 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2715 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2716 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2717 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2718 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2719 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2720 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2721 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2722 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2723 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2724 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2725 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2726 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2727 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2728 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2729 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2730 };
2731
2732 while (len--)
2733 {
2734 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2735 buff++;
2736 }
2737 }
2738
2739 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2740 {
2741 unsigned long i = *ppos;
2742 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2743
2744 DECLARE_WAITQUEUE(wait, current);
2745
2746 if (j->flags.inread)
2747 return -EALREADY;
2748
2749 j->flags.inread = 1;
2750
2751 add_wait_queue(&j->read_q, &wait);
2752 set_current_state(TASK_INTERRUPTIBLE);
2753 mb();
2754
2755 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2756 ++j->read_wait;
2757 if (file_p->f_flags & O_NONBLOCK) {
2758 set_current_state(TASK_RUNNING);
2759 remove_wait_queue(&j->read_q, &wait);
2760 j->flags.inread = 0;
2761 return -EAGAIN;
2762 }
2763 if (!ixj_hookstate(j)) {
2764 set_current_state(TASK_RUNNING);
2765 remove_wait_queue(&j->read_q, &wait);
2766 j->flags.inread = 0;
2767 return 0;
2768 }
2769 interruptible_sleep_on(&j->read_q);
2770 if (signal_pending(current)) {
2771 set_current_state(TASK_RUNNING);
2772 remove_wait_queue(&j->read_q, &wait);
2773 j->flags.inread = 0;
2774 return -EINTR;
2775 }
2776 }
2777
2778 remove_wait_queue(&j->read_q, &wait);
2779 set_current_state(TASK_RUNNING);
2780 /* Don't ever copy more than the user asks */
2781 if(j->rec_codec == ALAW)
2782 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2783 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2784 j->read_buffer_ready = 0;
2785 if (i) {
2786 j->flags.inread = 0;
2787 return -EFAULT;
2788 } else {
2789 j->flags.inread = 0;
2790 return min(length, j->read_buffer_size);
2791 }
2792 }
2793
2794 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2795 loff_t * ppos)
2796 {
2797 int pre_retval;
2798 ssize_t read_retval = 0;
2799 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2800
2801 pre_retval = ixj_PreRead(j, 0L);
2802 switch (pre_retval) {
2803 case NORMAL:
2804 read_retval = ixj_read(file_p, buf, length, ppos);
2805 ixj_PostRead(j, 0L);
2806 break;
2807 case NOPOST:
2808 read_retval = ixj_read(file_p, buf, length, ppos);
2809 break;
2810 case POSTONLY:
2811 ixj_PostRead(j, 0L);
2812 break;
2813 default:
2814 read_retval = pre_retval;
2815 }
2816 return read_retval;
2817 }
2818
2819 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2820 {
2821 unsigned long i = *ppos;
2822 IXJ *j = file_p->private_data;
2823
2824 DECLARE_WAITQUEUE(wait, current);
2825
2826 if (j->flags.inwrite)
2827 return -EALREADY;
2828
2829 j->flags.inwrite = 1;
2830
2831 add_wait_queue(&j->write_q, &wait);
2832 set_current_state(TASK_INTERRUPTIBLE);
2833 mb();
2834
2835
2836 while (!j->write_buffers_empty) {
2837 ++j->write_wait;
2838 if (file_p->f_flags & O_NONBLOCK) {
2839 set_current_state(TASK_RUNNING);
2840 remove_wait_queue(&j->write_q, &wait);
2841 j->flags.inwrite = 0;
2842 return -EAGAIN;
2843 }
2844 if (!ixj_hookstate(j)) {
2845 set_current_state(TASK_RUNNING);
2846 remove_wait_queue(&j->write_q, &wait);
2847 j->flags.inwrite = 0;
2848 return 0;
2849 }
2850 interruptible_sleep_on(&j->write_q);
2851 if (signal_pending(current)) {
2852 set_current_state(TASK_RUNNING);
2853 remove_wait_queue(&j->write_q, &wait);
2854 j->flags.inwrite = 0;
2855 return -EINTR;
2856 }
2857 }
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 if (j->write_buffer_wp + count >= j->write_buffer_end)
2861 j->write_buffer_wp = j->write_buffer;
2862 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2863 if (i) {
2864 j->flags.inwrite = 0;
2865 return -EFAULT;
2866 }
2867 if(j->play_codec == ALAW)
2868 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2869 j->flags.inwrite = 0;
2870 return min(count, j->write_buffer_size);
2871 }
2872
2873 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2874 {
2875 int pre_retval;
2876 ssize_t write_retval = 0;
2877
2878 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2879
2880 pre_retval = ixj_PreWrite(j, 0L);
2881 switch (pre_retval) {
2882 case NORMAL:
2883 write_retval = ixj_write(file_p, buf, count, ppos);
2884 if (write_retval > 0) {
2885 ixj_PostWrite(j, 0L);
2886 j->write_buffer_wp += write_retval;
2887 j->write_buffers_empty--;
2888 }
2889 break;
2890 case NOPOST:
2891 write_retval = ixj_write(file_p, buf, count, ppos);
2892 if (write_retval > 0) {
2893 j->write_buffer_wp += write_retval;
2894 j->write_buffers_empty--;
2895 }
2896 break;
2897 case POSTONLY:
2898 ixj_PostWrite(j, 0L);
2899 break;
2900 default:
2901 write_retval = pre_retval;
2902 }
2903 return write_retval;
2904 }
2905
2906 static void ixj_read_frame(IXJ *j)
2907 {
2908 int cnt, dly;
2909
2910 if (j->read_buffer) {
2911 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2912 if (!(cnt % 16) && !IsRxReady(j)) {
2913 dly = 0;
2914 while (!IsRxReady(j)) {
2915 if (dly++ > 5) {
2916 dly = 0;
2917 break;
2918 }
2919 udelay(10);
2920 }
2921 }
2922 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2923 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2924 inb_p(j->DSPbase + 0x0E);
2925 inb_p(j->DSPbase + 0x0F);
2926 }
2927 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2928 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2929 }
2930 ++j->framesread;
2931 if (j->intercom != -1) {
2932 if (IsTxReady(get_ixj(j->intercom))) {
2933 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2934 if (!(cnt % 16) && !IsTxReady(j)) {
2935 dly = 0;
2936 while (!IsTxReady(j)) {
2937 if (dly++ > 5) {
2938 dly = 0;
2939 break;
2940 }
2941 udelay(10);
2942 }
2943 }
2944 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2945 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2946 }
2947 get_ixj(j->intercom)->frameswritten++;
2948 }
2949 } else {
2950 j->read_buffer_ready = 1;
2951 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2952
2953 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2954
2955 if(j->ixj_signals[SIG_READ_READY])
2956 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2957 }
2958 }
2959 }
2960
2961 static short fsk[][6][20] =
2962 {
2963 {
2964 {
2965 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2966 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2967 },
2968 {
2969 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2970 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2971 },
2972 {
2973 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2974 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2975 },
2976 {
2977 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2978 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2979 },
2980 {
2981 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2982 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2983 },
2984 {
2985 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2986 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2987 }
2988 },
2989 {
2990 {
2991 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2992 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2993 },
2994 {
2995 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
2996 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
2997 },
2998 {
2999 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3000 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3001 },
3002 {
3003 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3004 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3005 },
3006 {
3007 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3008 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3009 },
3010 {
3011 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3012 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3013 }
3014 }
3015 };
3016
3017
3018 static void ixj_write_cid_bit(IXJ *j, int bit)
3019 {
3020 while (j->fskcnt < 20) {
3021 if(j->fskdcnt < (j->fsksize - 1))
3022 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3023
3024 j->fskcnt += 3;
3025 }
3026 j->fskcnt %= 20;
3027
3028 if (!bit)
3029 j->fskz++;
3030 if (j->fskz >= 6)
3031 j->fskz = 0;
3032
3033 }
3034
3035 static void ixj_write_cid_byte(IXJ *j, char byte)
3036 {
3037 IXJ_CBYTE cb;
3038
3039 cb.cbyte = byte;
3040 ixj_write_cid_bit(j, 0);
3041 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3042 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3043 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3044 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3045 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3046 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3047 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3049 ixj_write_cid_bit(j, 1);
3050 }
3051
3052 static void ixj_write_cid_seize(IXJ *j)
3053 {
3054 int cnt;
3055
3056 for (cnt = 0; cnt < 150; cnt++) {
3057 ixj_write_cid_bit(j, 0);
3058 ixj_write_cid_bit(j, 1);
3059 }
3060 for (cnt = 0; cnt < 180; cnt++) {
3061 ixj_write_cid_bit(j, 1);
3062 }
3063 }
3064
3065 static void ixj_write_cidcw_seize(IXJ *j)
3066 {
3067 int cnt;
3068
3069 for (cnt = 0; cnt < 80; cnt++) {
3070 ixj_write_cid_bit(j, 1);
3071 }
3072 }
3073
3074 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3075 {
3076 int cnt;
3077
3078 for (cnt = 0; cnt < strlen(s); cnt++) {
3079 ixj_write_cid_byte(j, s[cnt]);
3080 checksum = (checksum + s[cnt]);
3081 }
3082 return checksum;
3083 }
3084
3085 static void ixj_pad_fsk(IXJ *j, int pad)
3086 {
3087 int cnt;
3088
3089 for (cnt = 0; cnt < pad; cnt++) {
3090 if(j->fskdcnt < (j->fsksize - 1))
3091 j->fskdata[j->fskdcnt++] = 0x0000;
3092 }
3093 for (cnt = 0; cnt < 720; cnt++) {
3094 if(j->fskdcnt < (j->fsksize - 1))
3095 j->fskdata[j->fskdcnt++] = 0x0000;
3096 }
3097 }
3098
3099 static void ixj_pre_cid(IXJ *j)
3100 {
3101 j->cid_play_codec = j->play_codec;
3102 j->cid_play_frame_size = j->play_frame_size;
3103 j->cid_play_volume = get_play_volume(j);
3104 j->cid_play_flag = j->flags.playing;
3105
3106 j->cid_rec_codec = j->rec_codec;
3107 j->cid_rec_volume = get_rec_volume(j);
3108 j->cid_rec_flag = j->flags.recording;
3109
3110 j->cid_play_aec_level = j->aec_level;
3111
3112 switch(j->baseframe.low) {
3113 case 0xA0:
3114 j->cid_base_frame_size = 20;
3115 break;
3116 case 0x50:
3117 j->cid_base_frame_size = 10;
3118 break;
3119 case 0xF0:
3120 j->cid_base_frame_size = 30;
3121 break;
3122 }
3123
3124 ixj_play_stop(j);
3125 ixj_cpt_stop(j);
3126
3127 j->flags.cidplay = 1;
3128
3129 set_base_frame(j, 30);
3130 set_play_codec(j, LINEAR16);
3131 set_play_volume(j, 0x1B);
3132 ixj_play_start(j);
3133 }
3134
3135 static void ixj_post_cid(IXJ *j)
3136 {
3137 ixj_play_stop(j);
3138
3139 if(j->cidsize > 5000) {
3140 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3141 }
3142 j->flags.cidplay = 0;
3143 if(ixjdebug & 0x0200) {
3144 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3145 }
3146
3147 ixj_fsk_free(j);
3148
3149 j->fskdcnt = 0;
3150 set_base_frame(j, j->cid_base_frame_size);
3151 set_play_codec(j, j->cid_play_codec);
3152 ixj_aec_start(j, j->cid_play_aec_level);
3153 set_play_volume(j, j->cid_play_volume);
3154
3155 set_rec_codec(j, j->cid_rec_codec);
3156 set_rec_volume(j, j->cid_rec_volume);
3157
3158 if(j->cid_rec_flag)
3159 ixj_record_start(j);
3160
3161 if(j->cid_play_flag)
3162 ixj_play_start(j);
3163
3164 if(j->cid_play_flag) {
3165 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3166 }
3167 }
3168
3169 static void ixj_write_cid(IXJ *j)
3170 {
3171 char sdmf1[50];
3172 char sdmf2[50];
3173 char sdmf3[80];
3174 char mdmflen, len1, len2, len3;
3175 int pad;
3176
3177 int checksum = 0;
3178
3179 if (j->dsp.low == 0x20 || j->flags.cidplay)
3180 return;
3181
3182 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3183 j->cidsize = j->cidcnt = 0;
3184
3185 ixj_fsk_alloc(j);
3186
3187 strcpy(sdmf1, j->cid_send.month);
3188 strcat(sdmf1, j->cid_send.day);
3189 strcat(sdmf1, j->cid_send.hour);
3190 strcat(sdmf1, j->cid_send.min);
3191 strcpy(sdmf2, j->cid_send.number);
3192 strcpy(sdmf3, j->cid_send.name);
3193
3194 len1 = strlen(sdmf1);
3195 len2 = strlen(sdmf2);
3196 len3 = strlen(sdmf3);
3197 mdmflen = len1 + len2 + len3 + 6;
3198
3199 while(1){
3200 ixj_write_cid_seize(j);
3201
3202 ixj_write_cid_byte(j, 0x80);
3203 checksum = 0x80;
3204 ixj_write_cid_byte(j, mdmflen);
3205 checksum = checksum + mdmflen;
3206
3207 ixj_write_cid_byte(j, 0x01);
3208 checksum = checksum + 0x01;
3209 ixj_write_cid_byte(j, len1);
3210 checksum = checksum + len1;
3211 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3212 if(ixj_hookstate(j) & 1)
3213 break;
3214
3215 ixj_write_cid_byte(j, 0x02);
3216 checksum = checksum + 0x02;
3217 ixj_write_cid_byte(j, len2);
3218 checksum = checksum + len2;
3219 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3220 if(ixj_hookstate(j) & 1)
3221 break;
3222
3223 ixj_write_cid_byte(j, 0x07);
3224 checksum = checksum + 0x07;
3225 ixj_write_cid_byte(j, len3);
3226 checksum = checksum + len3;
3227 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3228 if(ixj_hookstate(j) & 1)
3229 break;
3230
3231 checksum %= 256;
3232 checksum ^= 0xFF;
3233 checksum += 1;
3234
3235 ixj_write_cid_byte(j, (char) checksum);
3236
3237 pad = j->fskdcnt % 240;
3238 if (pad) {
3239 pad = 240 - pad;
3240 }
3241 ixj_pad_fsk(j, pad);
3242 break;
3243 }
3244
3245 ixj_write_frame(j);
3246 }
3247
3248 static void ixj_write_cidcw(IXJ *j)
3249 {
3250 IXJ_TONE ti;
3251
3252 char sdmf1[50];
3253 char sdmf2[50];
3254 char sdmf3[80];
3255 char mdmflen, len1, len2, len3;
3256 int pad;
3257
3258 int checksum = 0;
3259
3260 if (j->dsp.low == 0x20 || j->flags.cidplay)
3261 return;
3262
3263 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3264 j->cidsize = j->cidcnt = 0;
3265
3266 ixj_fsk_alloc(j);
3267
3268 j->flags.cidcw_ack = 0;
3269
3270 ti.tone_index = 23;
3271 ti.gain0 = 1;
3272 ti.freq0 = hz440;
3273 ti.gain1 = 0;
3274 ti.freq1 = 0;
3275 ixj_init_tone(j, &ti);
3276
3277 ixj_set_tone_on(1500, j);
3278 ixj_set_tone_off(32, j);
3279 if(ixjdebug & 0x0200) {
3280 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3281 }
3282 ixj_play_tone(j, 23);
3283
3284 clear_bit(j->board, &j->busyflags);
3285 while(j->tone_state)
3286 schedule_timeout_interruptible(1);
3287 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3288 schedule_timeout_interruptible(1);
3289 if(ixjdebug & 0x0200) {
3290 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3291 }
3292
3293 ti.tone_index = 24;
3294 ti.gain0 = 1;
3295 ti.freq0 = hz2130;
3296 ti.gain1 = 0;
3297 ti.freq1 = hz2750;
3298 ixj_init_tone(j, &ti);
3299
3300 ixj_set_tone_off(10, j);
3301 ixj_set_tone_on(600, j);
3302 if(ixjdebug & 0x0200) {
3303 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3304 }
3305 ixj_play_tone(j, 24);
3306
3307 clear_bit(j->board, &j->busyflags);
3308 while(j->tone_state)
3309 schedule_timeout_interruptible(1);
3310 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3311 schedule_timeout_interruptible(1);
3312 if(ixjdebug & 0x0200) {
3313 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3314 }
3315
3316 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3317
3318 clear_bit(j->board, &j->busyflags);
3319 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3320 schedule_timeout_interruptible(1);
3321 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3322 schedule_timeout_interruptible(1);
3323 j->cidcw_wait = 0;
3324 if(!j->flags.cidcw_ack) {
3325 if(ixjdebug & 0x0200) {
3326 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3327 }
3328 ixj_post_cid(j);
3329 if(j->cid_play_flag) {
3330 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3331 }
3332 return;
3333 } else {
3334 ixj_pre_cid(j);
3335 }
3336 j->flags.cidcw_ack = 0;
3337 strcpy(sdmf1, j->cid_send.month);
3338 strcat(sdmf1, j->cid_send.day);
3339 strcat(sdmf1, j->cid_send.hour);
3340 strcat(sdmf1, j->cid_send.min);
3341 strcpy(sdmf2, j->cid_send.number);
3342 strcpy(sdmf3, j->cid_send.name);
3343
3344 len1 = strlen(sdmf1);
3345 len2 = strlen(sdmf2);
3346 len3 = strlen(sdmf3);
3347 mdmflen = len1 + len2 + len3 + 6;
3348
3349 ixj_write_cidcw_seize(j);
3350
3351 ixj_write_cid_byte(j, 0x80);
3352 checksum = 0x80;
3353 ixj_write_cid_byte(j, mdmflen);
3354 checksum = checksum + mdmflen;
3355
3356 ixj_write_cid_byte(j, 0x01);
3357 checksum = checksum + 0x01;
3358 ixj_write_cid_byte(j, len1);
3359 checksum = checksum + len1;
3360 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3361
3362 ixj_write_cid_byte(j, 0x02);
3363 checksum = checksum + 0x02;
3364 ixj_write_cid_byte(j, len2);
3365 checksum = checksum + len2;
3366 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3367
3368 ixj_write_cid_byte(j, 0x07);
3369 checksum = checksum + 0x07;
3370 ixj_write_cid_byte(j, len3);
3371 checksum = checksum + len3;
3372 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3373
3374 checksum %= 256;
3375 checksum ^= 0xFF;
3376 checksum += 1;
3377
3378 ixj_write_cid_byte(j, (char) checksum);
3379
3380 pad = j->fskdcnt % 240;
3381 if (pad) {
3382 pad = 240 - pad;
3383 }
3384 ixj_pad_fsk(j, pad);
3385 if(ixjdebug & 0x0200) {
3386 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3387 }
3388 }
3389
3390 static void ixj_write_vmwi(IXJ *j, int msg)
3391 {
3392 char mdmflen;
3393 int pad;
3394
3395 int checksum = 0;
3396
3397 if (j->dsp.low == 0x20 || j->flags.cidplay)
3398 return;
3399
3400 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3401 j->cidsize = j->cidcnt = 0;
3402
3403 ixj_fsk_alloc(j);
3404
3405 mdmflen = 3;
3406
3407 if (j->port == PORT_POTS)
3408 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3409
3410 ixj_write_cid_seize(j);
3411
3412 ixj_write_cid_byte(j, 0x82);
3413 checksum = 0x82;
3414 ixj_write_cid_byte(j, mdmflen);
3415 checksum = checksum + mdmflen;
3416
3417 ixj_write_cid_byte(j, 0x0B);
3418 checksum = checksum + 0x0B;
3419 ixj_write_cid_byte(j, 1);
3420 checksum = checksum + 1;
3421
3422 if(msg) {
3423 ixj_write_cid_byte(j, 0xFF);
3424 checksum = checksum + 0xFF;
3425 }
3426 else {
3427 ixj_write_cid_byte(j, 0x00);
3428 checksum = checksum + 0x00;
3429 }
3430
3431 checksum %= 256;
3432 checksum ^= 0xFF;
3433 checksum += 1;
3434
3435 ixj_write_cid_byte(j, (char) checksum);
3436
3437 pad = j->fskdcnt % 240;
3438 if (pad) {
3439 pad = 240 - pad;
3440 }
3441 ixj_pad_fsk(j, pad);
3442 }
3443
3444 static void ixj_write_frame(IXJ *j)
3445 {
3446 int cnt, frame_count, dly;
3447 IXJ_WORD dat;
3448 BYTES blankword;
3449
3450 frame_count = 0;
3451 if(j->flags.cidplay) {
3452 for(cnt = 0; cnt < 480; cnt++) {
3453 if (!(cnt % 16) && !IsTxReady(j)) {
3454 dly = 0;
3455 while (!IsTxReady(j)) {
3456 if (dly++ > 5) {
3457 dly = 0;
3458 break;
3459 }
3460 udelay(10);
3461 }
3462 }
3463 dat.word = j->fskdata[j->cidcnt++];
3464 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3465 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3466 cnt++;
3467 }
3468 if(j->cidcnt >= j->fskdcnt) {
3469 ixj_post_cid(j);
3470 }
3471 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3472 and there is real audio data in the buffer, we need to throw it away because
3473 we just used it's time slot */
3474 if (j->write_buffer_rp > j->write_buffer_wp) {
3475 j->write_buffer_rp += j->cid_play_frame_size * 2;
3476 if (j->write_buffer_rp >= j->write_buffer_end) {
3477 j->write_buffer_rp = j->write_buffer;
3478 }
3479 j->write_buffers_empty++;
3480 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3481
3482 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3483 }
3484 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3485 if (j->write_buffer_wp > j->write_buffer_rp) {
3486 frame_count =
3487 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3488 }
3489 if (j->write_buffer_rp > j->write_buffer_wp) {
3490 frame_count =
3491 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3492 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3493 }
3494 if (frame_count >= 1) {
3495 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3496 switch (j->play_mode) {
3497 case PLAYBACK_MODE_ULAW:
3498 case PLAYBACK_MODE_ALAW:
3499 blankword.low = blankword.high = 0xFF;
3500 break;
3501 case PLAYBACK_MODE_8LINEAR:
3502 case PLAYBACK_MODE_16LINEAR:
3503 blankword.low = blankword.high = 0x00;
3504 break;
3505 case PLAYBACK_MODE_8LINEAR_WSS:
3506 blankword.low = blankword.high = 0x80;
3507 break;
3508 }
3509 for (cnt = 0; cnt < 16; cnt++) {
3510 if (!(cnt % 16) && !IsTxReady(j)) {
3511 dly = 0;
3512 while (!IsTxReady(j)) {
3513 if (dly++ > 5) {
3514 dly = 0;
3515 break;
3516 }
3517 udelay(10);
3518 }
3519 }
3520 outb_p((blankword.low), j->DSPbase + 0x0C);
3521 outb_p((blankword.high), j->DSPbase + 0x0D);
3522 }
3523 j->flags.play_first_frame = 0;
3524 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3525 for (cnt = 0; cnt < 24; cnt++) {
3526 if(cnt == 12) {
3527 blankword.low = 0x02;
3528 blankword.high = 0x00;
3529 }
3530 else {
3531 blankword.low = blankword.high = 0x00;
3532 }
3533 if (!(cnt % 16) && !IsTxReady(j)) {
3534 dly = 0;
3535 while (!IsTxReady(j)) {
3536 if (dly++ > 5) {
3537 dly = 0;
3538 break;
3539 }
3540 udelay(10);
3541 }
3542 }
3543 outb_p((blankword.low), j->DSPbase + 0x0C);
3544 outb_p((blankword.high), j->DSPbase + 0x0D);
3545 }
3546 j->flags.play_first_frame = 0;
3547 }
3548 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3549 if (!(cnt % 16) && !IsTxReady(j)) {
3550 dly = 0;
3551 while (!IsTxReady(j)) {
3552 if (dly++ > 5) {
3553 dly = 0;
3554 break;
3555 }
3556 udelay(10);
3557 }
3558 }
3559 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3560 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3561 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3562 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3563 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3564 j->write_buffer_rp + cnt + 9 == 0) {
3565 /* someone is trying to write silence lets make this a type 0 frame. */
3566 outb_p(0x00, j->DSPbase + 0x0C);
3567 outb_p(0x00, j->DSPbase + 0x0D);
3568 } else {
3569 /* so all other frames are type 1. */
3570 outb_p(0x01, j->DSPbase + 0x0C);
3571 outb_p(0x00, j->DSPbase + 0x0D);
3572 }
3573 }
3574 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3575 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3576 *(j->write_buffer_rp + cnt) = 0;
3577 *(j->write_buffer_rp + cnt + 1) = 0;
3578 }
3579 j->write_buffer_rp += j->play_frame_size * 2;
3580 if (j->write_buffer_rp >= j->write_buffer_end) {
3581 j->write_buffer_rp = j->write_buffer;
3582 }
3583 j->write_buffers_empty++;
3584 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3585
3586 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3587
3588 ++j->frameswritten;
3589 }
3590 } else {
3591 j->drybuffer++;
3592 }
3593 if(j->ixj_signals[SIG_WRITE_READY]) {
3594 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3595 }
3596 }
3597
3598 static int idle(IXJ *j)
3599 {
3600 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3601
3602 return 0;
3603
3604 if (j->ssr.high || j->ssr.low) {
3605 return 0;
3606 } else {
3607 j->play_mode = -1;
3608 j->flags.playing = 0;
3609 j->rec_mode = -1;
3610 j->flags.recording = 0;
3611 return 1;
3612 }
3613 }
3614
3615 static int set_base_frame(IXJ *j, int size)
3616 {
3617 unsigned short cmd;
3618 int cnt;
3619
3620 idle(j);
3621 j->cid_play_aec_level = j->aec_level;
3622 aec_stop(j);
3623 for (cnt = 0; cnt < 10; cnt++) {
3624 if (idle(j))
3625 break;
3626 }
3627 if (j->ssr.high || j->ssr.low)
3628 return -1;
3629 if (j->dsp.low != 0x20) {
3630 switch (size) {
3631 case 30:
3632 cmd = 0x07F0;
3633 /* Set Base Frame Size to 240 pg9-10 8021 */
3634 break;
3635 case 20:
3636 cmd = 0x07A0;
3637 /* Set Base Frame Size to 160 pg9-10 8021 */
3638 break;
3639 case 10:
3640 cmd = 0x0750;
3641 /* Set Base Frame Size to 80 pg9-10 8021 */
3642 break;
3643 default:
3644 return -1;
3645 }
3646 } else {
3647 if (size == 30)
3648 return size;
3649 else
3650 return -1;
3651 }
3652 if (ixj_WriteDSPCommand(cmd, j)) {
3653 j->baseframe.high = j->baseframe.low = 0xFF;
3654 return -1;
3655 } else {
3656 j->baseframe.high = j->ssr.high;
3657 j->baseframe.low = j->ssr.low;
3658 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3659 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3660 return -1;
3661 }
3662 }
3663 ixj_aec_start(j, j->cid_play_aec_level);
3664 return size;
3665 }
3666
3667 static int set_rec_codec(IXJ *j, int rate)
3668 {
3669 int retval = 0;
3670
3671 j->rec_codec = rate;
3672
3673 switch (rate) {
3674 case G723_63:
3675 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3676 j->rec_frame_size = 12;
3677 j->rec_mode = 0;
3678 } else {
3679 retval = 1;
3680 }
3681 break;
3682 case G723_53:
3683 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3684 j->rec_frame_size = 10;
3685 j->rec_mode = 0;
3686 } else {
3687 retval = 1;
3688 }
3689 break;
3690 case TS85:
3691 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3692 j->rec_frame_size = 16;
3693 j->rec_mode = 0;
3694 } else {
3695 retval = 1;
3696 }
3697 break;
3698 case TS48:
3699 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700 j->rec_frame_size = 9;
3701 j->rec_mode = 0;
3702 } else {
3703 retval = 1;
3704 }
3705 break;
3706 case TS41:
3707 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3708 j->rec_frame_size = 8;
3709 j->rec_mode = 0;
3710 } else {
3711 retval = 1;
3712 }
3713 break;
3714 case G728:
3715 if (j->dsp.low != 0x20) {
3716 j->rec_frame_size = 48;
3717 j->rec_mode = 0;
3718 } else {
3719 retval = 1;
3720 }
3721 break;
3722 case G729:
3723 if (j->dsp.low != 0x20) {
3724 if (!j->flags.g729_loaded) {
3725 retval = 1;
3726 break;
3727 }
3728 switch (j->baseframe.low) {
3729 case 0xA0:
3730 j->rec_frame_size = 10;
3731 break;
3732 case 0x50:
3733 j->rec_frame_size = 5;
3734 break;
3735 default:
3736 j->rec_frame_size = 15;
3737 break;
3738 }
3739 j->rec_mode = 0;
3740 } else {
3741 retval = 1;
3742 }
3743 break;
3744 case G729B:
3745 if (j->dsp.low != 0x20) {
3746 if (!j->flags.g729_loaded) {
3747 retval = 1;
3748 break;
3749 }
3750 switch (j->baseframe.low) {
3751 case 0xA0:
3752 j->rec_frame_size = 12;
3753 break;
3754 case 0x50:
3755 j->rec_frame_size = 6;
3756 break;
3757 default:
3758 j->rec_frame_size = 18;
3759 break;
3760 }
3761 j->rec_mode = 0;
3762 } else {
3763 retval = 1;
3764 }
3765 break;
3766 case ULAW:
3767 switch (j->baseframe.low) {
3768 case 0xA0:
3769 j->rec_frame_size = 80;
3770 break;
3771 case 0x50:
3772 j->rec_frame_size = 40;
3773 break;
3774 default:
3775 j->rec_frame_size = 120;
3776 break;
3777 }
3778 j->rec_mode = 4;
3779 break;
3780 case ALAW:
3781 switch (j->baseframe.low) {
3782 case 0xA0:
3783 j->rec_frame_size = 80;
3784 break;
3785 case 0x50:
3786 j->rec_frame_size = 40;
3787 break;
3788 default:
3789 j->rec_frame_size = 120;
3790 break;
3791 }
3792 j->rec_mode = 4;
3793 break;
3794 case LINEAR16:
3795 switch (j->baseframe.low) {
3796 case 0xA0:
3797 j->rec_frame_size = 160;
3798 break;
3799 case 0x50:
3800 j->rec_frame_size = 80;
3801 break;
3802 default:
3803 j->rec_frame_size = 240;
3804 break;
3805 }
3806 j->rec_mode = 5;
3807 break;
3808 case LINEAR8:
3809 switch (j->baseframe.low) {
3810 case 0xA0:
3811 j->rec_frame_size = 80;
3812 break;
3813 case 0x50:
3814 j->rec_frame_size = 40;
3815 break;
3816 default:
3817 j->rec_frame_size = 120;
3818 break;
3819 }
3820 j->rec_mode = 6;
3821 break;
3822 case WSS:
3823 switch (j->baseframe.low) {
3824 case 0xA0:
3825 j->rec_frame_size = 80;
3826 break;
3827 case 0x50:
3828 j->rec_frame_size = 40;
3829 break;
3830 default:
3831 j->rec_frame_size = 120;
3832 break;
3833 }
3834 j->rec_mode = 7;
3835 break;
3836 default:
3837 kfree(j->read_buffer);
3838 j->rec_frame_size = 0;
3839 j->rec_mode = -1;
3840 j->read_buffer = NULL;
3841 j->read_buffer_size = 0;
3842 retval = 1;
3843 break;
3844 }
3845 return retval;
3846 }
3847
3848 static int ixj_record_start(IXJ *j)
3849 {
3850 unsigned short cmd = 0x0000;
3851
3852 if (j->read_buffer) {
3853 ixj_record_stop(j);
3854 }
3855 j->flags.recording = 1;
3856 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3857
3858 if(ixjdebug & 0x0002)
3859 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3860
3861 if (!j->rec_mode) {
3862 switch (j->rec_codec) {
3863 case G723_63:
3864 cmd = 0x5131;
3865 break;
3866 case G723_53:
3867 cmd = 0x5132;
3868 break;
3869 case TS85:
3870 cmd = 0x5130; /* TrueSpeech 8.5 */
3871
3872 break;
3873 case TS48:
3874 cmd = 0x5133; /* TrueSpeech 4.8 */
3875
3876 break;
3877 case TS41:
3878 cmd = 0x5134; /* TrueSpeech 4.1 */
3879
3880 break;
3881 case G728:
3882 cmd = 0x5135;
3883 break;
3884 case G729:
3885 case G729B:
3886 cmd = 0x5136;
3887 break;
3888 default:
3889 return 1;
3890 }
3891 if (ixj_WriteDSPCommand(cmd, j))
3892 return -1;
3893 }
3894 if (!j->read_buffer) {
3895 if (!j->read_buffer)
3896 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3897 if (!j->read_buffer) {
3898 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3899 return -ENOMEM;
3900 }
3901 }
3902 j->read_buffer_size = j->rec_frame_size * 2;
3903
3904 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3905
3906 return -1;
3907
3908 switch (j->rec_mode) {
3909 case 0:
3910 cmd = 0x1C03; /* Record C1 */
3911
3912 break;
3913 case 4:
3914 if (j->ver.low == 0x12) {
3915 cmd = 0x1E03; /* Record C1 */
3916
3917 } else {
3918 cmd = 0x1E01; /* Record C1 */
3919
3920 }
3921 break;
3922 case 5:
3923 if (j->ver.low == 0x12) {
3924 cmd = 0x1E83; /* Record C1 */
3925
3926 } else {
3927 cmd = 0x1E81; /* Record C1 */
3928
3929 }
3930 break;
3931 case 6:
3932 if (j->ver.low == 0x12) {
3933 cmd = 0x1F03; /* Record C1 */
3934
3935 } else {
3936 cmd = 0x1F01; /* Record C1 */
3937
3938 }
3939 break;
3940 case 7:
3941 if (j->ver.low == 0x12) {
3942 cmd = 0x1F83; /* Record C1 */
3943 } else {
3944 cmd = 0x1F81; /* Record C1 */
3945 }
3946 break;
3947 }
3948 if (ixj_WriteDSPCommand(cmd, j))
3949 return -1;
3950
3951 if (j->flags.playing) {
3952 ixj_aec_start(j, j->aec_level);
3953 }
3954 return 0;
3955 }
3956
3957 static void ixj_record_stop(IXJ *j)
3958 {
3959 if (ixjdebug & 0x0002)
3960 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3961
3962 kfree(j->read_buffer);
3963 j->read_buffer = NULL;
3964 j->read_buffer_size = 0;
3965 if (j->rec_mode > -1) {
3966 ixj_WriteDSPCommand(0x5120, j);
3967 j->rec_mode = -1;
3968 }
3969 j->flags.recording = 0;
3970 }
3971 static void ixj_vad(IXJ *j, int arg)
3972 {
3973 if (arg)
3974 ixj_WriteDSPCommand(0x513F, j);
3975 else
3976 ixj_WriteDSPCommand(0x513E, j);
3977 }
3978
3979 static void set_rec_depth(IXJ *j, int depth)
3980 {
3981 if (depth > 60)
3982 depth = 60;
3983 if (depth < 0)
3984 depth = 0;
3985 ixj_WriteDSPCommand(0x5180 + depth, j);
3986 }
3987
3988 static void set_dtmf_prescale(IXJ *j, int volume)
3989 {
3990 ixj_WriteDSPCommand(0xCF07, j);
3991 ixj_WriteDSPCommand(volume, j);
3992 }
3993
3994 static int get_dtmf_prescale(IXJ *j)
3995 {
3996 ixj_WriteDSPCommand(0xCF05, j);
3997 return j->ssr.high << 8 | j->ssr.low;
3998 }
3999
4000 static void set_rec_volume(IXJ *j, int volume)
4001 {
4002 if(j->aec_level == AEC_AGC) {
4003 if (ixjdebug & 0x0002)
4004 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4005 ixj_WriteDSPCommand(0xCF96, j);
4006 ixj_WriteDSPCommand(volume, j);
4007 } else {
4008 if (ixjdebug & 0x0002)
4009 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4010 ixj_WriteDSPCommand(0xCF03, j);
4011 ixj_WriteDSPCommand(volume, j);
4012 }
4013 }
4014
4015 static int set_rec_volume_linear(IXJ *j, int volume)
4016 {
4017 int newvolume, dsprecmax;
4018
4019 if (ixjdebug & 0x0002)
4020 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4021 if(volume > 100 || volume < 0) {
4022 return -1;
4023 }
4024
4025 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4026 switch (j->cardtype) {
4027 case QTI_PHONEJACK:
4028 dsprecmax = 0x440;
4029 break;
4030 case QTI_LINEJACK:
4031 dsprecmax = 0x180;
4032 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4033 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4034 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4035 break;
4036 case QTI_PHONEJACK_LITE:
4037 dsprecmax = 0x4C0;
4038 break;
4039 case QTI_PHONEJACK_PCI:
4040 dsprecmax = 0x100;
4041 break;
4042 case QTI_PHONECARD:
4043 dsprecmax = 0x400;
4044 break;
4045 default:
4046 return -1;
4047 }
4048 newvolume = (dsprecmax * volume) / 100;
4049 set_rec_volume(j, newvolume);
4050 return 0;
4051 }
4052
4053 static int get_rec_volume(IXJ *j)
4054 {
4055 if(j->aec_level == AEC_AGC) {
4056 if (ixjdebug & 0x0002)
4057 printk(KERN_INFO "Getting AGC Threshold\n");
4058 ixj_WriteDSPCommand(0xCF86, j);
4059 if (ixjdebug & 0x0002)
4060 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4061 return j->ssr.high << 8 | j->ssr.low;
4062 } else {
4063 if (ixjdebug & 0x0002)
4064 printk(KERN_INFO "Getting Record Volume\n");
4065 ixj_WriteDSPCommand(0xCF01, j);
4066 return j->ssr.high << 8 | j->ssr.low;
4067 }
4068 }
4069
4070 static int get_rec_volume_linear(IXJ *j)
4071 {
4072 int volume, newvolume, dsprecmax;
4073
4074 switch (j->cardtype) {
4075 case QTI_PHONEJACK:
4076 dsprecmax = 0x440;
4077 break;
4078 case QTI_LINEJACK:
4079 dsprecmax = 0x180;
4080 break;
4081 case QTI_PHONEJACK_LITE:
4082 dsprecmax = 0x4C0;
4083 break;
4084 case QTI_PHONEJACK_PCI:
4085 dsprecmax = 0x100;
4086 break;
4087 case QTI_PHONECARD:
4088 dsprecmax = 0x400;
4089 break;
4090 default:
4091 return -1;
4092 }
4093 volume = get_rec_volume(j);
4094 newvolume = (volume * 100) / dsprecmax;
4095 if(newvolume > 100)
4096 newvolume = 100;
4097 return newvolume;
4098 }
4099
4100 static int get_rec_level(IXJ *j)
4101 {
4102 int retval;
4103
4104 ixj_WriteDSPCommand(0xCF88, j);
4105
4106 retval = j->ssr.high << 8 | j->ssr.low;
4107 retval = (retval * 256) / 240;
4108 return retval;
4109 }
4110
4111 static void ixj_aec_start(IXJ *j, int level)
4112 {
4113 j->aec_level = level;
4114 if (ixjdebug & 0x0002)
4115 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4116 if (!level) {
4117 aec_stop(j);
4118 } else {
4119 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4120 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4121
4122 ixj_WriteDSPCommand(0x0300, j);
4123 }
4124 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4125
4126 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4127
4128 switch (level) {
4129 case AEC_LOW:
4130 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4131
4132 ixj_WriteDSPCommand(0xE011, j);
4133 ixj_WriteDSPCommand(0xFFFF, j);
4134
4135 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4136 ixj_WriteDSPCommand(0x0000, j); /* to off */
4137
4138 break;
4139
4140 case AEC_MED:
4141 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4142
4143 ixj_WriteDSPCommand(0xE011, j);
4144 ixj_WriteDSPCommand(0x0080, j);
4145
4146 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4147 ixj_WriteDSPCommand(0x0000, j); /* to off */
4148
4149 break;
4150
4151 case AEC_HIGH:
4152 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4153
4154 ixj_WriteDSPCommand(0xE011, j);
4155 ixj_WriteDSPCommand(0x0080, j);
4156
4157 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4158 ixj_WriteDSPCommand(0x0000, j); /* to off */
4159
4160 break;
4161
4162 case AEC_AGC:
4163 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4164 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4165
4166 ixj_WriteDSPCommand(0xE011, j);
4167 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4168
4169 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4170
4171 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4172 ixj_WriteDSPCommand(0x0224, j);
4173 else
4174 ixj_WriteDSPCommand(0x1224, j);
4175
4176 ixj_WriteDSPCommand(0xE014, j);
4177 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4178
4179 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4180
4181 /* Now we can set the AGC initial parameters and turn it on */
4182 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4183 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4184
4185 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4186 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4187
4188 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4189 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4190
4191 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4192 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4193
4194 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4195 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4196
4197 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4198 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4199
4200 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4201 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4202
4203 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4204 ixj_WriteDSPCommand(0x0001, j); /* to on */
4205
4206 break;
4207
4208 case AEC_AUTO:
4209 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4210
4211 ixj_WriteDSPCommand(0xE011, j);
4212 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4213
4214 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4215
4216 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4217 ixj_WriteDSPCommand(0x0224, j);
4218 else
4219 ixj_WriteDSPCommand(0x1224, j);
4220
4221 ixj_WriteDSPCommand(0xE014, j);
4222 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4223
4224 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4225
4226 break;
4227 }
4228 }
4229 }
4230
4231 static void aec_stop(IXJ *j)
4232 {
4233 j->aec_level = AEC_OFF;
4234 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4235 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4236
4237 ixj_WriteDSPCommand(0x0700, j);
4238 }
4239 if (j->play_mode != -1 && j->rec_mode != -1)
4240 {
4241 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4242 }
4243 }
4244
4245 static int set_play_codec(IXJ *j, int rate)
4246 {
4247 int retval = 0;
4248
4249 j->play_codec = rate;
4250
4251 switch (rate) {
4252 case G723_63:
4253 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4254 j->play_frame_size = 12;
4255 j->play_mode = 0;
4256 } else {
4257 retval = 1;
4258 }
4259 break;
4260 case G723_53:
4261 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4262 j->play_frame_size = 10;
4263 j->play_mode = 0;
4264 } else {
4265 retval = 1;
4266 }
4267 break;
4268 case TS85:
4269 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4270 j->play_frame_size = 16;
4271 j->play_mode = 0;
4272 } else {
4273 retval = 1;
4274 }
4275 break;
4276 case TS48:
4277 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278 j->play_frame_size = 9;
4279 j->play_mode = 0;
4280 } else {
4281 retval = 1;
4282 }
4283 break;
4284 case TS41:
4285 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4286 j->play_frame_size = 8;
4287 j->play_mode = 0;
4288 } else {
4289 retval = 1;
4290 }
4291 break;
4292 case G728:
4293 if (j->dsp.low != 0x20) {
4294 j->play_frame_size = 48;
4295 j->play_mode = 0;
4296 } else {
4297 retval = 1;
4298 }
4299 break;
4300 case G729:
4301 if (j->dsp.low != 0x20) {
4302 if (!j->flags.g729_loaded) {
4303 retval = 1;
4304 break;
4305 }
4306 switch (j->baseframe.low) {
4307 case 0xA0:
4308 j->play_frame_size = 10;
4309 break;
4310 case 0x50:
4311 j->play_frame_size = 5;
4312 break;
4313 default:
4314 j->play_frame_size = 15;
4315 break;
4316 }
4317 j->play_mode = 0;
4318 } else {
4319 retval = 1;
4320 }
4321 break;
4322 case G729B:
4323 if (j->dsp.low != 0x20) {
4324 if (!j->flags.g729_loaded) {
4325 retval = 1;
4326 break;
4327 }
4328 switch (j->baseframe.low) {
4329 case 0xA0:
4330 j->play_frame_size = 12;
4331 break;
4332 case 0x50:
4333 j->play_frame_size = 6;
4334 break;
4335 default:
4336 j->play_frame_size = 18;
4337 break;
4338 }
4339 j->play_mode = 0;
4340 } else {
4341 retval = 1;
4342 }
4343 break;
4344 case ULAW:
4345 switch (j->baseframe.low) {
4346 case 0xA0:
4347 j->play_frame_size = 80;
4348 break;
4349 case 0x50:
4350 j->play_frame_size = 40;
4351 break;
4352 default:
4353 j->play_frame_size = 120;
4354 break;
4355 }
4356 j->play_mode = 2;
4357 break;
4358 case ALAW:
4359 switch (j->baseframe.low) {
4360 case 0xA0:
4361 j->play_frame_size = 80;
4362 break;
4363 case 0x50:
4364 j->play_frame_size = 40;
4365 break;
4366 default:
4367 j->play_frame_size = 120;
4368 break;
4369 }
4370 j->play_mode = 2;
4371 break;
4372 case LINEAR16:
4373 switch (j->baseframe.low) {
4374 case 0xA0:
4375 j->play_frame_size = 160;
4376 break;
4377 case 0x50:
4378 j->play_frame_size = 80;
4379 break;
4380 default:
4381 j->play_frame_size = 240;
4382 break;
4383 }
4384 j->play_mode = 6;
4385 break;
4386 case LINEAR8:
4387 switch (j->baseframe.low) {
4388 case 0xA0:
4389 j->play_frame_size = 80;
4390 break;
4391 case 0x50:
4392 j->play_frame_size = 40;
4393 break;
4394 default:
4395 j->play_frame_size = 120;
4396 break;
4397 }
4398 j->play_mode = 4;
4399 break;
4400 case WSS:
4401 switch (j->baseframe.low) {
4402 case 0xA0:
4403 j->play_frame_size = 80;
4404 break;
4405 case 0x50:
4406 j->play_frame_size = 40;
4407 break;
4408 default:
4409 j->play_frame_size = 120;
4410 break;
4411 }
4412 j->play_mode = 5;
4413 break;
4414 default:
4415 kfree(j->write_buffer);
4416 j->play_frame_size = 0;
4417 j->play_mode = -1;
4418 j->write_buffer = NULL;
4419 j->write_buffer_size = 0;
4420 retval = 1;
4421 break;
4422 }
4423 return retval;
4424 }
4425
4426 static int ixj_play_start(IXJ *j)
4427 {
4428 unsigned short cmd = 0x0000;
4429
4430 if (j->write_buffer) {
4431 ixj_play_stop(j);
4432 }
4433
4434 if(ixjdebug & 0x0002)
4435 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4436
4437 j->flags.playing = 1;
4438 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4439
4440 j->flags.play_first_frame = 1;
4441 j->drybuffer = 0;
4442
4443 if (!j->play_mode) {
4444 switch (j->play_codec) {
4445 case G723_63:
4446 cmd = 0x5231;
4447 break;
4448 case G723_53:
4449 cmd = 0x5232;
4450 break;
4451 case TS85:
4452 cmd = 0x5230; /* TrueSpeech 8.5 */
4453
4454 break;
4455 case TS48:
4456 cmd = 0x5233; /* TrueSpeech 4.8 */
4457
4458 break;
4459 case TS41:
4460 cmd = 0x5234; /* TrueSpeech 4.1 */
4461
4462 break;
4463 case G728:
4464 cmd = 0x5235;
4465 break;
4466 case G729:
4467 case G729B:
4468 cmd = 0x5236;
4469 break;
4470 default:
4471 return 1;
4472 }
4473 if (ixj_WriteDSPCommand(cmd, j))
4474 return -1;
4475 }
4476 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4477 if (!j->write_buffer) {
4478 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4479 return -ENOMEM;
4480 }
4481 /* j->write_buffers_empty = 2; */
4482 j->write_buffers_empty = 1;
4483 j->write_buffer_size = j->play_frame_size * 2;
4484 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4485 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4486
4487 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4488
4489 return -1;
4490
4491 switch (j->play_mode) {
4492 case 0:
4493 cmd = 0x2C03;
4494 break;
4495 case 2:
4496 if (j->ver.low == 0x12) {
4497 cmd = 0x2C23;
4498 } else {
4499 cmd = 0x2C21;
4500 }
4501 break;
4502 case 4:
4503 if (j->ver.low == 0x12) {
4504 cmd = 0x2C43;
4505 } else {
4506 cmd = 0x2C41;
4507 }
4508 break;
4509 case 5:
4510 if (j->ver.low == 0x12) {
4511 cmd = 0x2C53;
4512 } else {
4513 cmd = 0x2C51;
4514 }
4515 break;
4516 case 6:
4517 if (j->ver.low == 0x12) {
4518 cmd = 0x2C63;
4519 } else {
4520 cmd = 0x2C61;
4521 }
4522 break;
4523 }
4524 if (ixj_WriteDSPCommand(cmd, j))
4525 return -1;
4526
4527 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4528 return -1;
4529
4530 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4531 return -1;
4532
4533 if (j->flags.recording) {
4534 ixj_aec_start(j, j->aec_level);
4535 }
4536
4537 return 0;
4538 }
4539
4540 static void ixj_play_stop(IXJ *j)
4541 {
4542 if (ixjdebug & 0x0002)
4543 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4544
4545 kfree(j->write_buffer);
4546 j->write_buffer = NULL;
4547 j->write_buffer_size = 0;
4548 if (j->play_mode > -1) {
4549 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4550
4551 j->play_mode = -1;
4552 }
4553 j->flags.playing = 0;
4554 }
4555
4556 static inline int get_play_level(IXJ *j)
4557 {
4558 int retval;
4559
4560 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4561 return j->ssr.high << 8 | j->ssr.low;
4562 retval = j->ssr.high << 8 | j->ssr.low;
4563 retval = (retval * 256) / 240;
4564 return retval;
4565 }
4566
4567 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4568 {
4569 unsigned int mask = 0;
4570
4571 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4572
4573 poll_wait(file_p, &(j->poll_q), wait);
4574 if (j->read_buffer_ready > 0)
4575 mask |= POLLIN | POLLRDNORM; /* readable */
4576 if (j->write_buffers_empty > 0)
4577 mask |= POLLOUT | POLLWRNORM; /* writable */
4578 if (j->ex.bytes)
4579 mask |= POLLPRI;
4580 return mask;
4581 }
4582
4583 static int ixj_play_tone(IXJ *j, char tone)
4584 {
4585 if (!j->tone_state) {
4586 if(ixjdebug & 0x0002) {
4587 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4588 }
4589 if (j->dsp.low == 0x20) {
4590 idle(j);
4591 }
4592 j->tone_start_jif = jiffies;
4593
4594 j->tone_state = 1;
4595 }
4596
4597 j->tone_index = tone;
4598 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4599 return -1;
4600
4601 return 0;
4602 }
4603
4604 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4605 {
4606 j->tone_on_time = arg;
4607
4608 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4609
4610 return -1;
4611
4612 if (ixj_WriteDSPCommand(arg, j))
4613 return -1;
4614
4615 return 0;
4616 }
4617
4618 static int SCI_WaitHighSCI(IXJ *j)
4619 {
4620 int cnt;
4621
4622 j->pld_scrr.byte = inb_p(j->XILINXbase);
4623 if (!j->pld_scrr.bits.sci) {
4624 for (cnt = 0; cnt < 10; cnt++) {
4625 udelay(32);
4626 j->pld_scrr.byte = inb_p(j->XILINXbase);
4627
4628 if ((j->pld_scrr.bits.sci))
4629 return 1;
4630 }
4631 if (ixjdebug & 0x0001)
4632 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4633 return 0;
4634 } else
4635 return 1;
4636 }
4637
4638 static int SCI_WaitLowSCI(IXJ *j)
4639 {
4640 int cnt;
4641
4642 j->pld_scrr.byte = inb_p(j->XILINXbase);
4643 if (j->pld_scrr.bits.sci) {
4644 for (cnt = 0; cnt < 10; cnt++) {
4645 udelay(32);
4646 j->pld_scrr.byte = inb_p(j->XILINXbase);
4647
4648 if (!(j->pld_scrr.bits.sci))
4649 return 1;
4650 }
4651 if (ixjdebug & 0x0001)
4652 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4653 return 0;
4654 } else
4655 return 1;
4656 }
4657
4658 static int SCI_Control(IXJ *j, int control)
4659 {
4660 switch (control) {
4661 case SCI_End:
4662 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4663
4664 j->pld_scrw.bits.c1 = 0; /* to no selection */
4665
4666 break;
4667 case SCI_Enable_DAA:
4668 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4669
4670 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4671
4672 break;
4673 case SCI_Enable_Mixer:
4674 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4675
4676 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4677
4678 break;
4679 case SCI_Enable_EEPROM:
4680 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4681
4682 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4683
4684 break;
4685 default:
4686 return 0;
4687 break;
4688 }
4689 outb_p(j->pld_scrw.byte, j->XILINXbase);
4690
4691 switch (control) {
4692 case SCI_End:
4693 return 1;
4694 break;
4695 case SCI_Enable_DAA:
4696 case SCI_Enable_Mixer:
4697 case SCI_Enable_EEPROM:
4698 if (!SCI_WaitHighSCI(j))
4699 return 0;
4700 break;
4701 default:
4702 return 0;
4703 break;
4704 }
4705 return 1;
4706 }
4707
4708 static int SCI_Prepare(IXJ *j)
4709 {
4710 if (!SCI_Control(j, SCI_End))
4711 return 0;
4712
4713 if (!SCI_WaitLowSCI(j))
4714 return 0;
4715
4716 return 1;
4717 }
4718
4719 static int ixj_get_mixer(long val, IXJ *j)
4720 {
4721 int reg = (val & 0x1F00) >> 8;
4722 return j->mix.vol[reg];
4723 }
4724
4725 static int ixj_mixer(long val, IXJ *j)
4726 {
4727 BYTES bytes;
4728
4729 bytes.high = (val & 0x1F00) >> 8;
4730 bytes.low = val & 0x00FF;
4731
4732 /* save mixer value so we can get back later on */
4733 j->mix.vol[bytes.high] = bytes.low;
4734
4735 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4736
4737 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4738
4739 SCI_Control(j, SCI_Enable_Mixer);
4740
4741 SCI_Control(j, SCI_End);
4742
4743 return 0;
4744 }
4745
4746 static int daa_load(BYTES * p_bytes, IXJ *j)
4747 {
4748 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4749 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4750 if (!SCI_Control(j, SCI_Enable_DAA))
4751 return 0;
4752 else
4753 return 1;
4754 }
4755
4756 static int ixj_daa_cr4(IXJ *j, char reg)
4757 {
4758 BYTES bytes;
4759
4760 switch (j->daa_mode) {
4761 case SOP_PU_SLEEP:
4762 bytes.high = 0x14;
4763 break;
4764 case SOP_PU_RINGING:
4765 bytes.high = 0x54;
4766 break;
4767 case SOP_PU_CONVERSATION:
4768 bytes.high = 0x94;
4769 break;
4770 case SOP_PU_PULSEDIALING:
4771 bytes.high = 0xD4;
4772 break;
4773 }
4774
4775 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4776
4777 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4778 case 0:
4779 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4780 break;
4781 case 1:
4782 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4783 break;
4784 case 2:
4785 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4786 break;
4787 case 3:
4788 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4789 break;
4790 }
4791
4792 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4793
4794 if (!daa_load(&bytes, j))
4795 return 0;
4796
4797 if (!SCI_Prepare(j))
4798 return 0;
4799
4800 return 1;
4801 }
4802
4803 static char daa_int_read(IXJ *j)
4804 {
4805 BYTES bytes;
4806
4807 if (!SCI_Prepare(j))
4808 return 0;
4809
4810 bytes.high = 0x38;
4811 bytes.low = 0x00;
4812 outb_p(bytes.high, j->XILINXbase + 0x03);
4813 outb_p(bytes.low, j->XILINXbase + 0x02);
4814
4815 if (!SCI_Control(j, SCI_Enable_DAA))
4816 return 0;
4817
4818 bytes.high = inb_p(j->XILINXbase + 0x03);
4819 bytes.low = inb_p(j->XILINXbase + 0x02);
4820 if (bytes.low != ALISDAA_ID_BYTE) {
4821 if (ixjdebug & 0x0001)
4822 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4823 return 0;
4824 }
4825 if (!SCI_Control(j, SCI_Enable_DAA))
4826 return 0;
4827 if (!SCI_Control(j, SCI_End))
4828 return 0;
4829
4830 bytes.high = inb_p(j->XILINXbase + 0x03);
4831 bytes.low = inb_p(j->XILINXbase + 0x02);
4832
4833 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4834
4835 return 1;
4836 }
4837
4838 static char daa_CR_read(IXJ *j, int cr)
4839 {
4840 IXJ_WORD wdata;
4841 BYTES bytes;
4842
4843 if (!SCI_Prepare(j))
4844 return 0;
4845
4846 switch (j->daa_mode) {
4847 case SOP_PU_SLEEP:
4848 bytes.high = 0x30 + cr;
4849 break;
4850 case SOP_PU_RINGING:
4851 bytes.high = 0x70 + cr;
4852 break;
4853 case SOP_PU_CONVERSATION:
4854 bytes.high = 0xB0 + cr;
4855 break;
4856 case SOP_PU_PULSEDIALING:
4857 bytes.high = 0xF0 + cr;
4858 break;
4859 }
4860
4861 bytes.low = 0x00;
4862
4863 outb_p(bytes.high, j->XILINXbase + 0x03);
4864 outb_p(bytes.low, j->XILINXbase + 0x02);
4865
4866 if (!SCI_Control(j, SCI_Enable_DAA))
4867 return 0;
4868
4869 bytes.high = inb_p(j->XILINXbase + 0x03);
4870 bytes.low = inb_p(j->XILINXbase + 0x02);
4871 if (bytes.low != ALISDAA_ID_BYTE) {
4872 if (ixjdebug & 0x0001)
4873 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4874 return 0;
4875 }
4876 if (!SCI_Control(j, SCI_Enable_DAA))
4877 return 0;
4878 if (!SCI_Control(j, SCI_End))
4879 return 0;
4880
4881 wdata.word = inw_p(j->XILINXbase + 0x02);
4882
4883 switch(cr){
4884 case 5:
4885 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4886 break;
4887 case 4:
4888 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4889 break;
4890 case 3:
4891 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4892 break;
4893 case 2:
4894 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4895 break;
4896 case 1:
4897 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4898 break;
4899 case 0:
4900 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4901 break;
4902 default:
4903 return 0;
4904 }
4905 return 1;
4906 }
4907
4908 static int ixj_daa_cid_reset(IXJ *j)
4909 {
4910 int i;
4911 BYTES bytes;
4912
4913 if (ixjdebug & 0x0002)
4914 printk("DAA Clearing CID ram\n");
4915
4916 if (!SCI_Prepare(j))
4917 return 0;
4918
4919 bytes.high = 0x58;
4920 bytes.low = 0x00;
4921 outb_p(bytes.high, j->XILINXbase + 0x03);
4922 outb_p(bytes.low, j->XILINXbase + 0x02);
4923
4924 if (!SCI_Control(j, SCI_Enable_DAA))
4925 return 0;
4926
4927 if (!SCI_WaitHighSCI(j))
4928 return 0;
4929
4930 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4931 bytes.high = bytes.low = 0x00;
4932 outb_p(bytes.high, j->XILINXbase + 0x03);
4933
4934 if (i < ALISDAA_CALLERID_SIZE - 1)
4935 outb_p(bytes.low, j->XILINXbase + 0x02);
4936
4937 if (!SCI_Control(j, SCI_Enable_DAA))
4938 return 0;
4939
4940 if (!SCI_WaitHighSCI(j))
4941 return 0;
4942
4943 }
4944
4945 if (!SCI_Control(j, SCI_End))
4946 return 0;
4947
4948 if (ixjdebug & 0x0002)
4949 printk("DAA CID ram cleared\n");
4950
4951 return 1;
4952 }
4953
4954 static int ixj_daa_cid_read(IXJ *j)
4955 {
4956 int i;
4957 BYTES bytes;
4958 char CID[ALISDAA_CALLERID_SIZE], mContinue;
4959 char *pIn, *pOut;
4960
4961 if (!SCI_Prepare(j))
4962 return 0;
4963
4964 bytes.high = 0x78;
4965 bytes.low = 0x00;
4966 outb_p(bytes.high, j->XILINXbase + 0x03);
4967 outb_p(bytes.low, j->XILINXbase + 0x02);
4968
4969 if (!SCI_Control(j, SCI_Enable_DAA))
4970 return 0;
4971
4972 if (!SCI_WaitHighSCI(j))
4973 return 0;
4974
4975 bytes.high = inb_p(j->XILINXbase + 0x03);
4976 bytes.low = inb_p(j->XILINXbase + 0x02);
4977 if (bytes.low != ALISDAA_ID_BYTE) {
4978 if (ixjdebug & 0x0001)
4979 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4980 return 0;
4981 }
4982 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4983 bytes.high = bytes.low = 0x00;
4984 outb_p(bytes.high, j->XILINXbase + 0x03);
4985 outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987 if (!SCI_Control(j, SCI_Enable_DAA))
4988 return 0;
4989
4990 if (!SCI_WaitHighSCI(j))
4991 return 0;
4992
4993 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
4994 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
4995 }
4996
4997 if (!SCI_Control(j, SCI_End))
4998 return 0;
4999
5000 pIn = CID;
5001 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5002 mContinue = 1;
5003 while (mContinue) {
5004 if ((pIn[1] & 0x03) == 0x01) {
5005 pOut[0] = pIn[0];
5006 }
5007 if ((pIn[2] & 0x0c) == 0x04) {
5008 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5009 }
5010 if ((pIn[3] & 0x30) == 0x10) {
5011 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5012 }
5013 if ((pIn[4] & 0xc0) == 0x40) {
5014 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5015 } else {
5016 mContinue = FALSE;
5017 }
5018 pIn += 5, pOut += 4;
5019 }
5020 memset(&j->cid, 0, sizeof(PHONE_CID));
5021 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5022 pOut += 4;
5023 strncpy(j->cid.month, pOut, 2);
5024 pOut += 2;
5025 strncpy(j->cid.day, pOut, 2);
5026 pOut += 2;
5027 strncpy(j->cid.hour, pOut, 2);
5028 pOut += 2;
5029 strncpy(j->cid.min, pOut, 2);
5030 pOut += 3;
5031 j->cid.numlen = *pOut;
5032 pOut += 1;
5033 strncpy(j->cid.number, pOut, j->cid.numlen);
5034 pOut += j->cid.numlen + 1;
5035 j->cid.namelen = *pOut;
5036 pOut += 1;
5037 strncpy(j->cid.name, pOut, j->cid.namelen);
5038
5039 ixj_daa_cid_reset(j);
5040 return 1;
5041 }
5042
5043 static char daa_get_version(IXJ *j)
5044 {
5045 BYTES bytes;
5046
5047 if (!SCI_Prepare(j))
5048 return 0;
5049
5050 bytes.high = 0x35;
5051 bytes.low = 0x00;
5052 outb_p(bytes.high, j->XILINXbase + 0x03);
5053 outb_p(bytes.low, j->XILINXbase + 0x02);
5054
5055 if (!SCI_Control(j, SCI_Enable_DAA))
5056 return 0;
5057
5058 bytes.high = inb_p(j->XILINXbase + 0x03);
5059 bytes.low = inb_p(j->XILINXbase + 0x02);
5060 if (bytes.low != ALISDAA_ID_BYTE) {
5061 if (ixjdebug & 0x0001)
5062 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5063 return 0;
5064 }
5065 if (!SCI_Control(j, SCI_Enable_DAA))
5066 return 0;
5067
5068 if (!SCI_Control(j, SCI_End))
5069 return 0;
5070
5071 bytes.high = inb_p(j->XILINXbase + 0x03);
5072 bytes.low = inb_p(j->XILINXbase + 0x02);
5073 if (ixjdebug & 0x0002)
5074 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5075 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5076 return bytes.high;
5077 }
5078
5079 static int daa_set_mode(IXJ *j, int mode)
5080 {
5081 /* NOTE:
5082 The DAA *MUST* be in the conversation mode if the
5083 PSTN line is to be seized (PSTN line off-hook).
5084 Taking the PSTN line off-hook while the DAA is in
5085 a mode other than conversation mode will cause a
5086 hardware failure of the ALIS-A part.
5087
5088 NOTE:
5089 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5090 if the PSTN line is on-hook. Failure to have the PSTN line
5091 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5092 ALIS-A part.
5093 */
5094
5095 BYTES bytes;
5096
5097 j->flags.pstn_rmr = 0;
5098
5099 if (!SCI_Prepare(j))
5100 return 0;
5101
5102 switch (mode) {
5103 case SOP_PU_RESET:
5104 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5105
5106 outb_p(j->pld_scrw.byte, j->XILINXbase);
5107 j->pld_slicw.bits.rly2 = 0;
5108 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5109 bytes.high = 0x10;
5110 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5111 daa_load(&bytes, j);
5112 if (!SCI_Prepare(j))
5113 return 0;
5114
5115 j->daa_mode = SOP_PU_SLEEP;
5116 break;
5117 case SOP_PU_SLEEP:
5118 if(j->daa_mode == SOP_PU_SLEEP)
5119 {
5120 break;
5121 }
5122 if (ixjdebug & 0x0008)
5123 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5124 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5125 {
5126 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5127
5128 outb_p(j->pld_scrw.byte, j->XILINXbase);
5129 j->pld_slicw.bits.rly2 = 0;
5130 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5131 bytes.high = 0x10;
5132 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5133 daa_load(&bytes, j);
5134 if (!SCI_Prepare(j))
5135 return 0;
5136 }
5137 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5138
5139 outb_p(j->pld_scrw.byte, j->XILINXbase);
5140 j->pld_slicw.bits.rly2 = 0;
5141 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5142 bytes.high = 0x10;
5143 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5144 daa_load(&bytes, j);
5145 if (!SCI_Prepare(j))
5146 return 0;
5147
5148 j->daa_mode = SOP_PU_SLEEP;
5149 j->flags.pstn_ringing = 0;
5150 j->ex.bits.pstn_ring = 0;
5151 j->pstn_sleeptil = jiffies + (hertz / 4);
5152 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5153 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5154 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5155 break;
5156 case SOP_PU_RINGING:
5157 if (ixjdebug & 0x0008)
5158 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5159 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5160
5161 outb_p(j->pld_scrw.byte, j->XILINXbase);
5162 j->pld_slicw.bits.rly2 = 0;
5163 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5164 bytes.high = 0x50;
5165 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5166 daa_load(&bytes, j);
5167 if (!SCI_Prepare(j))
5168 return 0;
5169 j->daa_mode = SOP_PU_RINGING;
5170 break;
5171 case SOP_PU_CONVERSATION:
5172 if (ixjdebug & 0x0008)
5173 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5174 bytes.high = 0x90;
5175 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5176 daa_load(&bytes, j);
5177 if (!SCI_Prepare(j))
5178 return 0;
5179 j->pld_slicw.bits.rly2 = 1;
5180 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5181 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5182
5183 outb_p(j->pld_scrw.byte, j->XILINXbase);
5184 j->daa_mode = SOP_PU_CONVERSATION;
5185 j->flags.pstn_ringing = 0;
5186 j->ex.bits.pstn_ring = 0;
5187 j->pstn_sleeptil = jiffies;
5188 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5189 break;
5190 case SOP_PU_PULSEDIALING:
5191 if (ixjdebug & 0x0008)
5192 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5193 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5194
5195 outb_p(j->pld_scrw.byte, j->XILINXbase);
5196 j->pld_slicw.bits.rly2 = 0;
5197 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5198 bytes.high = 0xD0;
5199 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5200 daa_load(&bytes, j);
5201 if (!SCI_Prepare(j))
5202 return 0;
5203 j->daa_mode = SOP_PU_PULSEDIALING;
5204 break;
5205 default:
5206 break;
5207 }
5208 return 1;
5209 }
5210
5211 static int ixj_daa_write(IXJ *j)
5212 {
5213 BYTES bytes;
5214
5215 j->flags.pstncheck = 1;
5216
5217 daa_set_mode(j, SOP_PU_SLEEP);
5218
5219 if (!SCI_Prepare(j))
5220 return 0;
5221
5222 outb_p(j->pld_scrw.byte, j->XILINXbase);
5223
5224 bytes.high = 0x14;
5225 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5226 if (!daa_load(&bytes, j))
5227 return 0;
5228
5229 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5230 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5231 if (!daa_load(&bytes, j))
5232 return 0;
5233
5234 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5235 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5236 if (!daa_load(&bytes, j))
5237 return 0;
5238
5239 if (!SCI_Prepare(j))
5240 return 0;
5241
5242 bytes.high = 0x1F;
5243 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5244 if (!daa_load(&bytes, j))
5245 return 0;
5246
5247 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5248 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5249 if (!daa_load(&bytes, j))
5250 return 0;
5251
5252 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5253 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5254 if (!daa_load(&bytes, j))
5255 return 0;
5256
5257 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5258 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5259 if (!daa_load(&bytes, j))
5260 return 0;
5261
5262 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5263 bytes.low = 0x00;
5264 if (!daa_load(&bytes, j))
5265 return 0;
5266
5267 if (!SCI_Prepare(j))
5268 return 0;
5269
5270 bytes.high = 0x00;
5271 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5272 if (!daa_load(&bytes, j))
5273 return 0;
5274
5275 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5276 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5277 if (!daa_load(&bytes, j))
5278 return 0;
5279
5280 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5281 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5282 if (!daa_load(&bytes, j))
5283 return 0;
5284
5285 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5286 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5287 if (!daa_load(&bytes, j))
5288 return 0;
5289
5290 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5291 bytes.low = 0x00;
5292 if (!daa_load(&bytes, j))
5293 return 0;
5294
5295 if (!SCI_Control(j, SCI_End))
5296 return 0;
5297 if (!SCI_WaitLowSCI(j))
5298 return 0;
5299
5300 bytes.high = 0x01;
5301 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5302 if (!daa_load(&bytes, j))
5303 return 0;
5304
5305 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5306 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5307 if (!daa_load(&bytes, j))
5308 return 0;
5309
5310 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5311 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5312 if (!daa_load(&bytes, j))
5313 return 0;
5314
5315 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5316 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5317 if (!daa_load(&bytes, j))
5318 return 0;
5319
5320 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5321 bytes.low = 0x00;
5322 if (!daa_load(&bytes, j))
5323 return 0;
5324
5325 if (!SCI_Control(j, SCI_End))
5326 return 0;
5327 if (!SCI_WaitLowSCI(j))
5328 return 0;
5329
5330 bytes.high = 0x02;
5331 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5332 if (!daa_load(&bytes, j))
5333 return 0;
5334
5335 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5336 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5337 if (!daa_load(&bytes, j))
5338 return 0;
5339
5340 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5341 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5342 if (!daa_load(&bytes, j))
5343 return 0;
5344
5345 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5346 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5347 if (!daa_load(&bytes, j))
5348 return 0;
5349
5350 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5351 bytes.low = 0x00;
5352 if (!daa_load(&bytes, j))
5353 return 0;
5354
5355 if (!SCI_Control(j, SCI_End))
5356 return 0;
5357 if (!SCI_WaitLowSCI(j))
5358 return 0;
5359
5360 bytes.high = 0x03;
5361 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5362 if (!daa_load(&bytes, j))
5363 return 0;
5364
5365 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5366 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5367 if (!daa_load(&bytes, j))
5368 return 0;
5369
5370 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5371 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5372 if (!daa_load(&bytes, j))
5373 return 0;
5374
5375 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5376 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5377 if (!daa_load(&bytes, j))
5378 return 0;
5379
5380 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5381 bytes.low = 0x00;
5382 if (!daa_load(&bytes, j))
5383 return 0;
5384
5385 if (!SCI_Control(j, SCI_End))
5386 return 0;
5387 if (!SCI_WaitLowSCI(j))
5388 return 0;
5389
5390 bytes.high = 0x04;
5391 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5392 if (!daa_load(&bytes, j))
5393 return 0;
5394
5395 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5396 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5397 if (!daa_load(&bytes, j))
5398 return 0;
5399
5400 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5401 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5402 if (!daa_load(&bytes, j))
5403 return 0;
5404
5405 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5406 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5407 if (!daa_load(&bytes, j))
5408 return 0;
5409
5410 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5411 bytes.low = 0x00;
5412 if (!daa_load(&bytes, j))
5413 return 0;
5414
5415 if (!SCI_Control(j, SCI_End))
5416 return 0;
5417 if (!SCI_WaitLowSCI(j))
5418 return 0;
5419
5420 bytes.high = 0x05;
5421 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5422 if (!daa_load(&bytes, j))
5423 return 0;
5424
5425 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5426 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5427 if (!daa_load(&bytes, j))
5428 return 0;
5429
5430 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5431 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5432 if (!daa_load(&bytes, j))
5433 return 0;
5434
5435 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5436 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5437 if (!daa_load(&bytes, j))
5438 return 0;
5439
5440 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5441 bytes.low = 0x00;
5442 if (!daa_load(&bytes, j))
5443 return 0;
5444
5445 if (!SCI_Control(j, SCI_End))
5446 return 0;
5447 if (!SCI_WaitLowSCI(j))
5448 return 0;
5449
5450 bytes.high = 0x06;
5451 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5452 if (!daa_load(&bytes, j))
5453 return 0;
5454
5455 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5456 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5457 if (!daa_load(&bytes, j))
5458 return 0;
5459
5460 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5461 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5462 if (!daa_load(&bytes, j))
5463 return 0;
5464
5465 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5466 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5467 if (!daa_load(&bytes, j))
5468 return 0;
5469
5470 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5471 bytes.low = 0x00;
5472 if (!daa_load(&bytes, j))
5473 return 0;
5474
5475 if (!SCI_Control(j, SCI_End))
5476 return 0;
5477 if (!SCI_WaitLowSCI(j))
5478 return 0;
5479
5480 bytes.high = 0x07;
5481 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5482 if (!daa_load(&bytes, j))
5483 return 0;
5484
5485 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5486 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5487 if (!daa_load(&bytes, j))
5488 return 0;
5489
5490 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5491 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5492 if (!daa_load(&bytes, j))
5493 return 0;
5494
5495 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5496 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5497 if (!daa_load(&bytes, j))
5498 return 0;
5499
5500 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5501 bytes.low = 0x00;
5502 if (!daa_load(&bytes, j))
5503 return 0;
5504
5505 if (!SCI_Control(j, SCI_End))
5506 return 0;
5507 if (!SCI_WaitLowSCI(j))
5508 return 0;
5509
5510 bytes.high = 0x08;
5511 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5512 if (!daa_load(&bytes, j))
5513 return 0;
5514
5515 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5516 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5517 if (!daa_load(&bytes, j))
5518 return 0;
5519
5520 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5521 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5522 if (!daa_load(&bytes, j))
5523 return 0;
5524
5525 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5526 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5527 if (!daa_load(&bytes, j))
5528 return 0;
5529
5530 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5531 bytes.low = 0x00;
5532 if (!daa_load(&bytes, j))
5533 return 0;
5534
5535 if (!SCI_Control(j, SCI_End))
5536 return 0;
5537 if (!SCI_WaitLowSCI(j))
5538 return 0;
5539
5540 bytes.high = 0x09;
5541 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5542 if (!daa_load(&bytes, j))
5543 return 0;
5544
5545 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5546 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5547 if (!daa_load(&bytes, j))
5548 return 0;
5549
5550 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5551 bytes.low = 0x00;
5552 if (!daa_load(&bytes, j))
5553 return 0;
5554
5555 if (!SCI_Control(j, SCI_End))
5556 return 0;
5557 if (!SCI_WaitLowSCI(j))
5558 return 0;
5559
5560 bytes.high = 0x0A;
5561 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5562 if (!daa_load(&bytes, j))
5563 return 0;
5564
5565 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5566 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5567 if (!daa_load(&bytes, j))
5568 return 0;
5569
5570 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5571 bytes.low = 0x00;
5572 if (!daa_load(&bytes, j))
5573 return 0;
5574
5575 if (!SCI_Control(j, SCI_End))
5576 return 0;
5577 if (!SCI_WaitLowSCI(j))
5578 return 0;
5579
5580 bytes.high = 0x0B;
5581 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5582 if (!daa_load(&bytes, j))
5583 return 0;
5584
5585 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5586 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5587 if (!daa_load(&bytes, j))
5588 return 0;
5589
5590 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5591 bytes.low = 0x00;
5592 if (!daa_load(&bytes, j))
5593 return 0;
5594
5595 if (!SCI_Control(j, SCI_End))
5596 return 0;
5597 if (!SCI_WaitLowSCI(j))
5598 return 0;
5599
5600 bytes.high = 0x0C;
5601 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5602 if (!daa_load(&bytes, j))
5603 return 0;
5604
5605 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5606 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5607 if (!daa_load(&bytes, j))
5608 return 0;
5609
5610 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5611 bytes.low = 0x00;
5612 if (!daa_load(&bytes, j))
5613 return 0;
5614
5615 if (!SCI_Control(j, SCI_End))
5616 return 0;
5617 if (!SCI_WaitLowSCI(j))
5618 return 0;
5619
5620 bytes.high = 0x0D;
5621 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5622 if (!daa_load(&bytes, j))
5623 return 0;
5624
5625 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5626 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5627 if (!daa_load(&bytes, j))
5628 return 0;
5629
5630 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5631 bytes.low = 0x00;
5632 if (!daa_load(&bytes, j))
5633 return 0;
5634
5635 if (!SCI_Control(j, SCI_End))
5636 return 0;
5637 if (!SCI_WaitLowSCI(j))
5638 return 0;
5639
5640 bytes.high = 0x0E;
5641 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5642 if (!daa_load(&bytes, j))
5643 return 0;
5644
5645 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5646 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5647 if (!daa_load(&bytes, j))
5648 return 0;
5649
5650 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5651 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5652 if (!daa_load(&bytes, j))
5653 return 0;
5654
5655 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5656 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5657 if (!daa_load(&bytes, j))
5658 return 0;
5659
5660 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5661 bytes.low = 0x00;
5662 if (!daa_load(&bytes, j))
5663 return 0;
5664
5665 if (!SCI_Control(j, SCI_End))
5666 return 0;
5667 if (!SCI_WaitLowSCI(j))
5668 return 0;
5669
5670 bytes.high = 0x0F;
5671 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5672 if (!daa_load(&bytes, j))
5673 return 0;
5674
5675 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5676 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5677 if (!daa_load(&bytes, j))
5678 return 0;
5679
5680 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5681 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5682 if (!daa_load(&bytes, j))
5683 return 0;
5684
5685 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5686 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5687 if (!daa_load(&bytes, j))
5688 return 0;
5689
5690 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5691 bytes.low = 0x00;
5692 if (!daa_load(&bytes, j))
5693 return 0;
5694
5695 udelay(32);
5696 j->pld_scrr.byte = inb_p(j->XILINXbase);
5697 if (!SCI_Control(j, SCI_End))
5698 return 0;
5699
5700 outb_p(j->pld_scrw.byte, j->XILINXbase);
5701
5702 if (ixjdebug & 0x0002)
5703 printk("DAA Coefficients Loaded\n");
5704
5705 j->flags.pstncheck = 0;
5706 return 1;
5707 }
5708
5709 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5710 {
5711 j->tone_off_time = arg;
5712 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5713
5714 return -1;
5715 if (ixj_WriteDSPCommand(arg, j))
5716 return -1;
5717 return 0;
5718 }
5719
5720 static int ixj_get_tone_on(IXJ *j)
5721 {
5722 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5723
5724 return -1;
5725 return 0;
5726 }
5727
5728 static int ixj_get_tone_off(IXJ *j)
5729 {
5730 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5731
5732 return -1;
5733 return 0;
5734 }
5735
5736 static void ixj_busytone(IXJ *j)
5737 {
5738 j->flags.ringback = 0;
5739 j->flags.dialtone = 0;
5740 j->flags.busytone = 1;
5741 ixj_set_tone_on(0x07D0, j);
5742 ixj_set_tone_off(0x07D0, j);
5743 ixj_play_tone(j, 27);
5744 }
5745
5746 static void ixj_dialtone(IXJ *j)
5747 {
5748 j->flags.ringback = 0;
5749 j->flags.dialtone = 1;
5750 j->flags.busytone = 0;
5751 if (j->dsp.low == 0x20) {
5752 return;
5753 } else {
5754 ixj_set_tone_on(0xFFFF, j);
5755 ixj_set_tone_off(0x0000, j);
5756 ixj_play_tone(j, 25);
5757 }
5758 }
5759
5760 static void ixj_cpt_stop(IXJ *j)
5761 {
5762 if(j->tone_state || j->tone_cadence_state)
5763 {
5764 j->flags.dialtone = 0;
5765 j->flags.busytone = 0;
5766 j->flags.ringback = 0;
5767 ixj_set_tone_on(0x0001, j);
5768 ixj_set_tone_off(0x0000, j);
5769 ixj_play_tone(j, 0);
5770 j->tone_state = j->tone_cadence_state = 0;
5771 if (j->cadence_t) {
5772 kfree(j->cadence_t->ce);
5773 kfree(j->cadence_t);
5774 j->cadence_t = NULL;
5775 }
5776 }
5777 if (j->play_mode == -1 && j->rec_mode == -1)
5778 idle(j);
5779 if (j->play_mode != -1 && j->dsp.low == 0x20)
5780 ixj_play_start(j);
5781 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5782 ixj_record_start(j);
5783 }
5784
5785 static void ixj_ringback(IXJ *j)
5786 {
5787 j->flags.busytone = 0;
5788 j->flags.dialtone = 0;
5789 j->flags.ringback = 1;
5790 ixj_set_tone_on(0x0FA0, j);
5791 ixj_set_tone_off(0x2EE0, j);
5792 ixj_play_tone(j, 26);
5793 }
5794
5795 static void ixj_testram(IXJ *j)
5796 {
5797 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5798 }
5799
5800 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5801 {
5802 ixj_cadence *lcp;
5803 IXJ_CADENCE_ELEMENT __user *cep;
5804 IXJ_CADENCE_ELEMENT *lcep;
5805 IXJ_TONE ti;
5806 int err;
5807
5808 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5809 if (lcp == NULL)
5810 return -ENOMEM;
5811
5812 err = -EFAULT;
5813 if (copy_from_user(&lcp->elements_used,
5814 &cp->elements_used, sizeof(int)))
5815 goto out;
5816 if (copy_from_user(&lcp->termination,
5817 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5818 goto out;
5819 if (get_user(cep, &cp->ce))
5820 goto out;
5821
5822 err = -EINVAL;
5823 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5824 goto out;
5825
5826 err = -ENOMEM;
5827 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5828 if (!lcep)
5829 goto out;
5830
5831 err = -EFAULT;
5832 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5833 goto out1;
5834
5835 if (j->cadence_t) {
5836 kfree(j->cadence_t->ce);
5837 kfree(j->cadence_t);
5838 }
5839 lcp->ce = (void *) lcep;
5840 j->cadence_t = lcp;
5841 j->tone_cadence_state = 0;
5842 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5843 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5844 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5845 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5846 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5847 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5848 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5849 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5850 ixj_init_tone(j, &ti);
5851 }
5852 ixj_play_tone(j, lcp->ce[0].index);
5853 return 1;
5854 out1:
5855 kfree(lcep);
5856 out:
5857 kfree(lcp);
5858 return err;
5859 }
5860
5861 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5862 {
5863 IXJ_FILTER_CADENCE *lcp;
5864 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5865 if (lcp == NULL) {
5866 if(ixjdebug & 0x0001) {
5867 printk(KERN_INFO "Could not allocate memory for cadence\n");
5868 }
5869 return -ENOMEM;
5870 }
5871 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5872 if(ixjdebug & 0x0001) {
5873 printk(KERN_INFO "Could not copy cadence to kernel\n");
5874 }
5875 kfree(lcp);
5876 return -EFAULT;
5877 }
5878 if (lcp->filter > 5) {
5879 if(ixjdebug & 0x0001) {
5880 printk(KERN_INFO "Cadence out of range\n");
5881 }
5882 kfree(lcp);
5883 return -1;
5884 }
5885 j->cadence_f[lcp->filter].state = 0;
5886 j->cadence_f[lcp->filter].enable = lcp->enable;
5887 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5888 j->cadence_f[lcp->filter].on1 = lcp->on1;
5889 j->cadence_f[lcp->filter].on1min = 0;
5890 j->cadence_f[lcp->filter].on1max = 0;
5891 j->cadence_f[lcp->filter].off1 = lcp->off1;
5892 j->cadence_f[lcp->filter].off1min = 0;
5893 j->cadence_f[lcp->filter].off1max = 0;
5894 j->cadence_f[lcp->filter].on2 = lcp->on2;
5895 j->cadence_f[lcp->filter].on2min = 0;
5896 j->cadence_f[lcp->filter].on2max = 0;
5897 j->cadence_f[lcp->filter].off2 = lcp->off2;
5898 j->cadence_f[lcp->filter].off2min = 0;
5899 j->cadence_f[lcp->filter].off2max = 0;
5900 j->cadence_f[lcp->filter].on3 = lcp->on3;
5901 j->cadence_f[lcp->filter].on3min = 0;
5902 j->cadence_f[lcp->filter].on3max = 0;
5903 j->cadence_f[lcp->filter].off3 = lcp->off3;
5904 j->cadence_f[lcp->filter].off3min = 0;
5905 j->cadence_f[lcp->filter].off3max = 0;
5906 if(ixjdebug & 0x0002) {
5907 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5908 }
5909 kfree(lcp);
5910 return 0;
5911 }
5912
5913 static void add_caps(IXJ *j)
5914 {
5915 j->caps = 0;
5916 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5917 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5918 j->caplist[j->caps].captype = vendor;
5919 j->caplist[j->caps].handle = j->caps++;
5920 j->caplist[j->caps].captype = device;
5921 switch (j->cardtype) {
5922 case QTI_PHONEJACK:
5923 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5924 break;
5925 case QTI_LINEJACK:
5926 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5927 break;
5928 case QTI_PHONEJACK_LITE:
5929 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5930 break;
5931 case QTI_PHONEJACK_PCI:
5932 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5933 break;
5934 case QTI_PHONECARD:
5935 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5936 break;
5937 }
5938 j->caplist[j->caps].cap = j->cardtype;
5939 j->caplist[j->caps].handle = j->caps++;
5940 strcpy(j->caplist[j->caps].desc, "POTS");
5941 j->caplist[j->caps].captype = port;
5942 j->caplist[j->caps].cap = pots;
5943 j->caplist[j->caps].handle = j->caps++;
5944
5945 /* add devices that can do speaker/mic */
5946 switch (j->cardtype) {
5947 case QTI_PHONEJACK:
5948 case QTI_LINEJACK:
5949 case QTI_PHONEJACK_PCI:
5950 case QTI_PHONECARD:
5951 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5952 j->caplist[j->caps].captype = port;
5953 j->caplist[j->caps].cap = speaker;
5954 j->caplist[j->caps].handle = j->caps++;
5955 default:
5956 break;
5957 }
5958
5959 /* add devices that can do handset */
5960 switch (j->cardtype) {
5961 case QTI_PHONEJACK:
5962 strcpy(j->caplist[j->caps].desc, "HANDSET");
5963 j->caplist[j->caps].captype = port;
5964 j->caplist[j->caps].cap = handset;
5965 j->caplist[j->caps].handle = j->caps++;
5966 break;
5967 default:
5968 break;
5969 }
5970
5971 /* add devices that can do PSTN */
5972 switch (j->cardtype) {
5973 case QTI_LINEJACK:
5974 strcpy(j->caplist[j->caps].desc, "PSTN");
5975 j->caplist[j->caps].captype = port;
5976 j->caplist[j->caps].cap = pstn;
5977 j->caplist[j->caps].handle = j->caps++;
5978 break;
5979 default:
5980 break;
5981 }
5982
5983 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5984 strcpy(j->caplist[j->caps].desc, "ULAW");
5985 j->caplist[j->caps].captype = codec;
5986 j->caplist[j->caps].cap = ULAW;
5987 j->caplist[j->caps].handle = j->caps++;
5988
5989 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
5990 j->caplist[j->caps].captype = codec;
5991 j->caplist[j->caps].cap = LINEAR16;
5992 j->caplist[j->caps].handle = j->caps++;
5993
5994 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
5995 j->caplist[j->caps].captype = codec;
5996 j->caplist[j->caps].cap = LINEAR8;
5997 j->caplist[j->caps].handle = j->caps++;
5998
5999 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6000 j->caplist[j->caps].captype = codec;
6001 j->caplist[j->caps].cap = WSS;
6002 j->caplist[j->caps].handle = j->caps++;
6003
6004 /* software ALAW codec, made from ULAW */
6005 strcpy(j->caplist[j->caps].desc, "ALAW");
6006 j->caplist[j->caps].captype = codec;
6007 j->caplist[j->caps].cap = ALAW;
6008 j->caplist[j->caps].handle = j->caps++;
6009
6010 /* version 12 of the 8020 does the following codecs in a broken way */
6011 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6012 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6013 j->caplist[j->caps].captype = codec;
6014 j->caplist[j->caps].cap = G723_63;
6015 j->caplist[j->caps].handle = j->caps++;
6016
6017 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6018 j->caplist[j->caps].captype = codec;
6019 j->caplist[j->caps].cap = G723_53;
6020 j->caplist[j->caps].handle = j->caps++;
6021
6022 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6023 j->caplist[j->caps].captype = codec;
6024 j->caplist[j->caps].cap = TS48;
6025 j->caplist[j->caps].handle = j->caps++;
6026
6027 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6028 j->caplist[j->caps].captype = codec;
6029 j->caplist[j->caps].cap = TS41;
6030 j->caplist[j->caps].handle = j->caps++;
6031 }
6032
6033 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6034 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6035 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6036 j->caplist[j->caps].captype = codec;
6037 j->caplist[j->caps].cap = TS85;
6038 j->caplist[j->caps].handle = j->caps++;
6039 }
6040
6041 /* 8021 chips can do G728 */
6042 if (j->dsp.low == 0x21) {
6043 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6044 j->caplist[j->caps].captype = codec;
6045 j->caplist[j->caps].cap = G728;
6046 j->caplist[j->caps].handle = j->caps++;
6047 }
6048
6049 /* 8021/8022 chips can do G729 if loaded */
6050 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6051 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6052 j->caplist[j->caps].captype = codec;
6053 j->caplist[j->caps].cap = G729;
6054 j->caplist[j->caps].handle = j->caps++;
6055 }
6056 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6057 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6058 j->caplist[j->caps].captype = codec;
6059 j->caplist[j->caps].cap = G729B;
6060 j->caplist[j->caps].handle = j->caps++;
6061 }
6062 }
6063
6064 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6065 {
6066 int cnt;
6067 int retval = 0;
6068 for (cnt = 0; cnt < j->caps; cnt++) {
6069 if (pcreq->captype == j->caplist[cnt].captype
6070 && pcreq->cap == j->caplist[cnt].cap) {
6071 retval = 1;
6072 break;
6073 }
6074 }
6075 return retval;
6076 }
6077
6078 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6079 {
6080 IXJ_TONE ti;
6081 IXJ_FILTER jf;
6082 IXJ_FILTER_RAW jfr;
6083 void __user *argp = (void __user *)arg;
6084
6085 unsigned int raise, mant;
6086 unsigned int minor = iminor(inode);
6087 int board = NUM(inode);
6088
6089 IXJ *j = get_ixj(NUM(inode));
6090
6091 int retval = 0;
6092
6093 /*
6094 * Set up locks to ensure that only one process is talking to the DSP at a time.
6095 * This is necessary to keep the DSP from locking up.
6096 */
6097 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6098 schedule_timeout_interruptible(1);
6099 if (ixjdebug & 0x0040)
6100 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6101 if (minor >= IXJMAX) {
6102 clear_bit(board, &j->busyflags);
6103 return -ENODEV;
6104 }
6105 /*
6106 * Check ioctls only root can use.
6107 */
6108 if (!capable(CAP_SYS_ADMIN)) {
6109 switch (cmd) {
6110 case IXJCTL_TESTRAM:
6111 case IXJCTL_HZ:
6112 retval = -EPERM;
6113 }
6114 }
6115 switch (cmd) {
6116 case IXJCTL_TESTRAM:
6117 ixj_testram(j);
6118 retval = (j->ssr.high << 8) + j->ssr.low;
6119 break;
6120 case IXJCTL_CARDTYPE:
6121 retval = j->cardtype;
6122 break;
6123 case IXJCTL_SERIAL:
6124 retval = j->serial;
6125 break;
6126 case IXJCTL_VERSION:
6127 {
6128 char arg_str[100];
6129 snprintf(arg_str, sizeof(arg_str),
6130 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6131 IXJ_VER_MINOR, IXJ_BLD_VER);
6132 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6133 retval = -EFAULT;
6134 }
6135 break;
6136 case PHONE_RING_CADENCE:
6137 j->ring_cadence = arg;
6138 break;
6139 case IXJCTL_CIDCW:
6140 if(arg) {
6141 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6142 retval = -EFAULT;
6143 break;
6144 }
6145 } else {
6146 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6147 }
6148 ixj_write_cidcw(j);
6149 break;
6150 /* Binary compatbility */
6151 case OLD_PHONE_RING_START:
6152 arg = 0;
6153 /* Fall through */
6154 case PHONE_RING_START:
6155 if(arg) {
6156 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6157 retval = -EFAULT;
6158 break;
6159 }
6160 ixj_write_cid(j);
6161 } else {
6162 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6163 }
6164 ixj_ring_start(j);
6165 break;
6166 case PHONE_RING_STOP:
6167 j->flags.cringing = 0;
6168 if(j->cadence_f[5].enable) {
6169 j->cadence_f[5].state = 0;
6170 }
6171 ixj_ring_off(j);
6172 break;
6173 case PHONE_RING:
6174 retval = ixj_ring(j);
6175 break;
6176 case PHONE_EXCEPTION:
6177 retval = j->ex.bytes;
6178 if(j->ex.bits.flash) {
6179 j->flash_end = 0;
6180 j->ex.bits.flash = 0;
6181 }
6182 j->ex.bits.pstn_ring = 0;
6183 j->ex.bits.caller_id = 0;
6184 j->ex.bits.pstn_wink = 0;
6185 j->ex.bits.f0 = 0;
6186 j->ex.bits.f1 = 0;
6187 j->ex.bits.f2 = 0;
6188 j->ex.bits.f3 = 0;
6189 j->ex.bits.fc0 = 0;
6190 j->ex.bits.fc1 = 0;
6191 j->ex.bits.fc2 = 0;
6192 j->ex.bits.fc3 = 0;
6193 j->ex.bits.reserved = 0;
6194 break;
6195 case PHONE_HOOKSTATE:
6196 j->ex.bits.hookstate = 0;
6197 retval = j->hookstate; //j->r_hook;
6198 break;
6199 case IXJCTL_SET_LED:
6200 LED_SetState(arg, j);
6201 break;
6202 case PHONE_FRAME:
6203 retval = set_base_frame(j, arg);
6204 break;
6205 case PHONE_REC_CODEC:
6206 retval = set_rec_codec(j, arg);
6207 break;
6208 case PHONE_VAD:
6209 ixj_vad(j, arg);
6210 break;
6211 case PHONE_REC_START:
6212 ixj_record_start(j);
6213 break;
6214 case PHONE_REC_STOP:
6215 ixj_record_stop(j);
6216 break;
6217 case PHONE_REC_DEPTH:
6218 set_rec_depth(j, arg);
6219 break;
6220 case PHONE_REC_VOLUME:
6221 if(arg == -1) {
6222 retval = get_rec_volume(j);
6223 }
6224 else {
6225 set_rec_volume(j, arg);
6226 retval = arg;
6227 }
6228 break;
6229 case PHONE_REC_VOLUME_LINEAR:
6230 if(arg == -1) {
6231 retval = get_rec_volume_linear(j);
6232 }
6233 else {
6234 set_rec_volume_linear(j, arg);
6235 retval = arg;
6236 }
6237 break;
6238 case IXJCTL_DTMF_PRESCALE:
6239 if(arg == -1) {
6240 retval = get_dtmf_prescale(j);
6241 }
6242 else {
6243 set_dtmf_prescale(j, arg);
6244 retval = arg;
6245 }
6246 break;
6247 case PHONE_REC_LEVEL:
6248 retval = get_rec_level(j);
6249 break;
6250 case IXJCTL_SC_RXG:
6251 retval = ixj_siadc(j, arg);
6252 break;
6253 case IXJCTL_SC_TXG:
6254 retval = ixj_sidac(j, arg);
6255 break;
6256 case IXJCTL_AEC_START:
6257 ixj_aec_start(j, arg);
6258 break;
6259 case IXJCTL_AEC_STOP:
6260 aec_stop(j);
6261 break;
6262 case IXJCTL_AEC_GET_LEVEL:
6263 retval = j->aec_level;
6264 break;
6265 case PHONE_PLAY_CODEC:
6266 retval = set_play_codec(j, arg);
6267 break;
6268 case PHONE_PLAY_START:
6269 retval = ixj_play_start(j);
6270 break;
6271 case PHONE_PLAY_STOP:
6272 ixj_play_stop(j);
6273 break;
6274 case PHONE_PLAY_DEPTH:
6275 set_play_depth(j, arg);
6276 break;
6277 case PHONE_PLAY_VOLUME:
6278 if(arg == -1) {
6279 retval = get_play_volume(j);
6280 }
6281 else {
6282 set_play_volume(j, arg);
6283 retval = arg;
6284 }
6285 break;
6286 case PHONE_PLAY_VOLUME_LINEAR:
6287 if(arg == -1) {
6288 retval = get_play_volume_linear(j);
6289 }
6290 else {
6291 set_play_volume_linear(j, arg);
6292 retval = arg;
6293 }
6294 break;
6295 case PHONE_PLAY_LEVEL:
6296 retval = get_play_level(j);
6297 break;
6298 case IXJCTL_DSP_TYPE:
6299 retval = (j->dsp.high << 8) + j->dsp.low;
6300 break;
6301 case IXJCTL_DSP_VERSION:
6302 retval = (j->ver.high << 8) + j->ver.low;
6303 break;
6304 case IXJCTL_HZ:
6305 hertz = arg;
6306 break;
6307 case IXJCTL_RATE:
6308 if (arg > hertz)
6309 retval = -1;
6310 else
6311 samplerate = arg;
6312 break;
6313 case IXJCTL_DRYBUFFER_READ:
6314 put_user(j->drybuffer, (unsigned long __user *) argp);
6315 break;
6316 case IXJCTL_DRYBUFFER_CLEAR:
6317 j->drybuffer = 0;
6318 break;
6319 case IXJCTL_FRAMES_READ:
6320 put_user(j->framesread, (unsigned long __user *) argp);
6321 break;
6322 case IXJCTL_FRAMES_WRITTEN:
6323 put_user(j->frameswritten, (unsigned long __user *) argp);
6324 break;
6325 case IXJCTL_READ_WAIT:
6326 put_user(j->read_wait, (unsigned long __user *) argp);
6327 break;
6328 case IXJCTL_WRITE_WAIT:
6329 put_user(j->write_wait, (unsigned long __user *) argp);
6330 break;
6331 case PHONE_MAXRINGS:
6332 j->maxrings = arg;
6333 break;
6334 case PHONE_SET_TONE_ON_TIME:
6335 ixj_set_tone_on(arg, j);
6336 break;
6337 case PHONE_SET_TONE_OFF_TIME:
6338 ixj_set_tone_off(arg, j);
6339 break;
6340 case PHONE_GET_TONE_ON_TIME:
6341 if (ixj_get_tone_on(j)) {
6342 retval = -1;
6343 } else {
6344 retval = (j->ssr.high << 8) + j->ssr.low;
6345 }
6346 break;
6347 case PHONE_GET_TONE_OFF_TIME:
6348 if (ixj_get_tone_off(j)) {
6349 retval = -1;
6350 } else {
6351 retval = (j->ssr.high << 8) + j->ssr.low;
6352 }
6353 break;
6354 case PHONE_PLAY_TONE:
6355 if (!j->tone_state)
6356 retval = ixj_play_tone(j, arg);
6357 else
6358 retval = -1;
6359 break;
6360 case PHONE_GET_TONE_STATE:
6361 retval = j->tone_state;
6362 break;
6363 case PHONE_DTMF_READY:
6364 retval = j->ex.bits.dtmf_ready;
6365 break;
6366 case PHONE_GET_DTMF:
6367 if (ixj_hookstate(j)) {
6368 if (j->dtmf_rp != j->dtmf_wp) {
6369 retval = j->dtmfbuffer[j->dtmf_rp];
6370 j->dtmf_rp++;
6371 if (j->dtmf_rp == 79)
6372 j->dtmf_rp = 0;
6373 if (j->dtmf_rp == j->dtmf_wp) {
6374 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6375 }
6376 }
6377 }
6378 break;
6379 case PHONE_GET_DTMF_ASCII:
6380 if (ixj_hookstate(j)) {
6381 if (j->dtmf_rp != j->dtmf_wp) {
6382 switch (j->dtmfbuffer[j->dtmf_rp]) {
6383 case 10:
6384 retval = 42; /* '*'; */
6385
6386 break;
6387 case 11:
6388 retval = 48; /*'0'; */
6389
6390 break;
6391 case 12:
6392 retval = 35; /*'#'; */
6393
6394 break;
6395 case 28:
6396 retval = 65; /*'A'; */
6397
6398 break;
6399 case 29:
6400 retval = 66; /*'B'; */
6401
6402 break;
6403 case 30:
6404 retval = 67; /*'C'; */
6405
6406 break;
6407 case 31:
6408 retval = 68; /*'D'; */
6409
6410 break;
6411 default:
6412 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6413 break;
6414 }
6415 j->dtmf_rp++;
6416 if (j->dtmf_rp == 79)
6417 j->dtmf_rp = 0;
6418 if(j->dtmf_rp == j->dtmf_wp)
6419 {
6420 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6421 }
6422 }
6423 }
6424 break;
6425 case PHONE_DTMF_OOB:
6426 j->flags.dtmf_oob = arg;
6427 break;
6428 case PHONE_DIALTONE:
6429 ixj_dialtone(j);
6430 break;
6431 case PHONE_BUSY:
6432 ixj_busytone(j);
6433 break;
6434 case PHONE_RINGBACK:
6435 ixj_ringback(j);
6436 break;
6437 case PHONE_WINK:
6438 if(j->cardtype == QTI_PHONEJACK)
6439 retval = -1;
6440 else
6441 retval = ixj_wink(j);
6442 break;
6443 case PHONE_CPT_STOP:
6444 ixj_cpt_stop(j);
6445 break;
6446 case PHONE_QUERY_CODEC:
6447 {
6448 struct phone_codec_data pd;
6449 int val;
6450 int proto_size[] = {
6451 -1,
6452 12, 10, 16, 9, 8, 48, 5,
6453 40, 40, 80, 40, 40, 6
6454 };
6455 if(copy_from_user(&pd, argp, sizeof(pd))) {
6456 retval = -EFAULT;
6457 break;
6458 }
6459 if(pd.type<1 || pd.type>13) {
6460 retval = -EPROTONOSUPPORT;
6461 break;
6462 }
6463 if(pd.type<G729)
6464 val=proto_size[pd.type];
6465 else switch(j->baseframe.low)
6466 {
6467 case 0xA0:val=2*proto_size[pd.type];break;
6468 case 0x50:val=proto_size[pd.type];break;
6469 default:val=proto_size[pd.type]*3;break;
6470 }
6471 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6472 if(copy_to_user(argp, &pd, sizeof(pd)))
6473 retval = -EFAULT;
6474 break;
6475 }
6476 case IXJCTL_DSP_IDLE:
6477 idle(j);
6478 break;
6479 case IXJCTL_MIXER:
6480 if ((arg & 0xff) == 0xff)
6481 retval = ixj_get_mixer(arg, j);
6482 else
6483 ixj_mixer(arg, j);
6484 break;
6485 case IXJCTL_DAA_COEFF_SET:
6486 switch (arg) {
6487 case DAA_US:
6488 DAA_Coeff_US(j);
6489 retval = ixj_daa_write(j);
6490 break;
6491 case DAA_UK:
6492 DAA_Coeff_UK(j);
6493 retval = ixj_daa_write(j);
6494 break;
6495 case DAA_FRANCE:
6496 DAA_Coeff_France(j);
6497 retval = ixj_daa_write(j);
6498 break;
6499 case DAA_GERMANY:
6500 DAA_Coeff_Germany(j);
6501 retval = ixj_daa_write(j);
6502 break;
6503 case DAA_AUSTRALIA:
6504 DAA_Coeff_Australia(j);
6505 retval = ixj_daa_write(j);
6506 break;
6507 case DAA_JAPAN:
6508 DAA_Coeff_Japan(j);
6509 retval = ixj_daa_write(j);
6510 break;
6511 default:
6512 retval = 1;
6513 break;
6514 }
6515 break;
6516 case IXJCTL_DAA_AGAIN:
6517 ixj_daa_cr4(j, arg | 0x02);
6518 break;
6519 case IXJCTL_PSTN_LINETEST:
6520 retval = ixj_linetest(j);
6521 break;
6522 case IXJCTL_VMWI:
6523 ixj_write_vmwi(j, arg);
6524 break;
6525 case IXJCTL_CID:
6526 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6527 retval = -EFAULT;
6528 j->ex.bits.caller_id = 0;
6529 break;
6530 case IXJCTL_WINK_DURATION:
6531 j->winktime = arg;
6532 break;
6533 case IXJCTL_PORT:
6534 if (arg)
6535 retval = ixj_set_port(j, arg);
6536 else
6537 retval = j->port;
6538 break;
6539 case IXJCTL_POTS_PSTN:
6540 retval = ixj_set_pots(j, arg);
6541 break;
6542 case PHONE_CAPABILITIES:
6543 add_caps(j);
6544 retval = j->caps;
6545 break;
6546 case PHONE_CAPABILITIES_LIST:
6547 add_caps(j);
6548 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6549 retval = -EFAULT;
6550 break;
6551 case PHONE_CAPABILITIES_CHECK:
6552 {
6553 struct phone_capability cap;
6554 if (copy_from_user(&cap, argp, sizeof(cap)))
6555 retval = -EFAULT;
6556 else {
6557 add_caps(j);
6558 retval = capabilities_check(j, &cap);
6559 }
6560 }
6561 break;
6562 case PHONE_PSTN_SET_STATE:
6563 daa_set_mode(j, arg);
6564 break;
6565 case PHONE_PSTN_GET_STATE:
6566 retval = j->daa_mode;
6567 j->ex.bits.pstn_ring = 0;
6568 break;
6569 case IXJCTL_SET_FILTER:
6570 if (copy_from_user(&jf, argp, sizeof(jf)))
6571 retval = -EFAULT;
6572 retval = ixj_init_filter(j, &jf);
6573 break;
6574 case IXJCTL_SET_FILTER_RAW:
6575 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6576 retval = -EFAULT;
6577 else
6578 retval = ixj_init_filter_raw(j, &jfr);
6579 break;
6580 case IXJCTL_GET_FILTER_HIST:
6581 if(arg<0||arg>3)
6582 retval = -EINVAL;
6583 else
6584 retval = j->filter_hist[arg];
6585 break;
6586 case IXJCTL_INIT_TONE:
6587 if (copy_from_user(&ti, argp, sizeof(ti)))
6588 retval = -EFAULT;
6589 else
6590 retval = ixj_init_tone(j, &ti);
6591 break;
6592 case IXJCTL_TONE_CADENCE:
6593 retval = ixj_build_cadence(j, argp);
6594 break;
6595 case IXJCTL_FILTER_CADENCE:
6596 retval = ixj_build_filter_cadence(j, argp);
6597 break;
6598 case IXJCTL_SIGCTL:
6599 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6600 retval = -EFAULT;
6601 break;
6602 }
6603 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6604 if(j->sigdef.event < 33) {
6605 raise = 1;
6606 for(mant = 0; mant < j->sigdef.event; mant++){
6607 raise *= 2;
6608 }
6609 if(j->sigdef.signal)
6610 j->ex_sig.bytes |= raise;
6611 else
6612 j->ex_sig.bytes &= (raise^0xffff);
6613 }
6614 break;
6615 case IXJCTL_INTERCOM_STOP:
6616 if(arg < 0 || arg >= IXJMAX)
6617 return -EINVAL;
6618 j->intercom = -1;
6619 ixj_record_stop(j);
6620 ixj_play_stop(j);
6621 idle(j);
6622 get_ixj(arg)->intercom = -1;
6623 ixj_record_stop(get_ixj(arg));
6624 ixj_play_stop(get_ixj(arg));
6625 idle(get_ixj(arg));
6626 break;
6627 case IXJCTL_INTERCOM_START:
6628 if(arg < 0 || arg >= IXJMAX)
6629 return -EINVAL;
6630 j->intercom = arg;
6631 ixj_record_start(j);
6632 ixj_play_start(j);
6633 get_ixj(arg)->intercom = board;
6634 ixj_play_start(get_ixj(arg));
6635 ixj_record_start(get_ixj(arg));
6636 break;
6637 }
6638 if (ixjdebug & 0x0040)
6639 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6640 clear_bit(board, &j->busyflags);
6641 return retval;
6642 }
6643
6644 static int ixj_fasync(int fd, struct file *file_p, int mode)
6645 {
6646 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6647
6648 return fasync_helper(fd, file_p, mode, &j->async_queue);
6649 }
6650
6651 static struct file_operations ixj_fops =
6652 {
6653 .owner = THIS_MODULE,
6654 .read = ixj_enhanced_read,
6655 .write = ixj_enhanced_write,
6656 .poll = ixj_poll,
6657 .ioctl = ixj_ioctl,
6658 .release = ixj_release,
6659 .fasync = ixj_fasync
6660 };
6661
6662 static int ixj_linetest(IXJ *j)
6663 {
6664 j->flags.pstncheck = 1; /* Testing */
6665 j->flags.pstn_present = 0; /* Assume the line is not there */
6666
6667 daa_int_read(j); /*Clear DAA Interrupt flags */
6668 /* */
6669 /* Hold all relays in the normally de-energized position. */
6670 /* */
6671
6672 j->pld_slicw.bits.rly1 = 0;
6673 j->pld_slicw.bits.rly2 = 0;
6674 j->pld_slicw.bits.rly3 = 0;
6675 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6676 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6677
6678 outb_p(j->pld_scrw.byte, j->XILINXbase);
6679 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6680 if (j->pld_slicr.bits.potspstn) {
6681 j->flags.pots_pstn = 1;
6682 j->flags.pots_correct = 0;
6683 LED_SetState(0x4, j);
6684 } else {
6685 j->flags.pots_pstn = 0;
6686 j->pld_slicw.bits.rly1 = 0;
6687 j->pld_slicw.bits.rly2 = 0;
6688 j->pld_slicw.bits.rly3 = 1;
6689 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6690 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6691
6692 outb_p(j->pld_scrw.byte, j->XILINXbase);
6693 daa_set_mode(j, SOP_PU_CONVERSATION);
6694 msleep(1000);
6695 daa_int_read(j);
6696 daa_set_mode(j, SOP_PU_RESET);
6697 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6698 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6699 LED_SetState(0x4, j);
6700 j->pld_slicw.bits.rly3 = 0;
6701 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6702 } else {
6703 j->flags.pots_correct = 1;
6704 LED_SetState(0x8, j);
6705 j->pld_slicw.bits.rly1 = 1;
6706 j->pld_slicw.bits.rly2 = 0;
6707 j->pld_slicw.bits.rly3 = 0;
6708 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6709 }
6710 }
6711 j->pld_slicw.bits.rly3 = 0;
6712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6713 daa_set_mode(j, SOP_PU_CONVERSATION);
6714 msleep(1000);
6715 daa_int_read(j);
6716 daa_set_mode(j, SOP_PU_RESET);
6717 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6718 j->pstn_sleeptil = jiffies + (hertz / 4);
6719 j->flags.pstn_present = 1;
6720 } else {
6721 j->flags.pstn_present = 0;
6722 }
6723 if (j->flags.pstn_present) {
6724 if (j->flags.pots_correct) {
6725 LED_SetState(0xA, j);
6726 } else {
6727 LED_SetState(0x6, j);
6728 }
6729 } else {
6730 if (j->flags.pots_correct) {
6731 LED_SetState(0x9, j);
6732 } else {
6733 LED_SetState(0x5, j);
6734 }
6735 }
6736 j->flags.pstncheck = 0; /* Testing */
6737 return j->flags.pstn_present;
6738 }
6739
6740 static int ixj_selfprobe(IXJ *j)
6741 {
6742 unsigned short cmd;
6743 int cnt;
6744 BYTES bytes;
6745
6746 init_waitqueue_head(&j->poll_q);
6747 init_waitqueue_head(&j->read_q);
6748 init_waitqueue_head(&j->write_q);
6749
6750 while(atomic_read(&j->DSPWrite) > 0)
6751 atomic_dec(&j->DSPWrite);
6752 if (ixjdebug & 0x0002)
6753 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6754 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6755
6756 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6757 return -1;
6758 /* The read values of the SSR should be 0x00 for the IDLE command */
6759 if (j->ssr.low || j->ssr.high)
6760 return -1;
6761 if (ixjdebug & 0x0002)
6762 printk(KERN_INFO "Get Device ID Code\n");
6763 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6764 return -1;
6765 j->dsp.low = j->ssr.low;
6766 j->dsp.high = j->ssr.high;
6767 if (ixjdebug & 0x0002)
6768 printk(KERN_INFO "Get Device Version Code\n");
6769 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6770 return -1;
6771 j->ver.low = j->ssr.low;
6772 j->ver.high = j->ssr.high;
6773 if (!j->cardtype) {
6774 if (j->dsp.low == 0x21) {
6775 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6776 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6777 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6778 bytes.low = inb_p(j->XILINXbase + 0x02);
6779 if (bytes.low == bytes.high) /* Register is read only on */
6780 /* Internet PhoneJack Lite */
6781 {
6782 j->cardtype = QTI_PHONEJACK_LITE;
6783 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6784 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6785 return -1;
6786 }
6787 j->pld_slicw.pcib.e1 = 1;
6788 outb_p(j->pld_slicw.byte, j->XILINXbase);
6789 } else {
6790 j->cardtype = QTI_LINEJACK;
6791
6792 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6793 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6794 return -1;
6795 }
6796 }
6797 } else if (j->dsp.low == 0x22) {
6798 j->cardtype = QTI_PHONEJACK_PCI;
6799 request_region(j->XILINXbase, 4, "ixj control");
6800 j->pld_slicw.pcib.e1 = 1;
6801 outb_p(j->pld_slicw.byte, j->XILINXbase);
6802 } else
6803 j->cardtype = QTI_PHONEJACK;
6804 } else {
6805 switch (j->cardtype) {
6806 case QTI_PHONEJACK:
6807 if (!j->dsp.low != 0x20) {
6808 j->dsp.high = 0x80;
6809 j->dsp.low = 0x20;
6810 ixj_WriteDSPCommand(0x3800, j);
6811 j->ver.low = j->ssr.low;
6812 j->ver.high = j->ssr.high;
6813 }
6814 break;
6815 case QTI_LINEJACK:
6816 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6817 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6818 return -1;
6819 }
6820 break;
6821 case QTI_PHONEJACK_LITE:
6822 case QTI_PHONEJACK_PCI:
6823 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6824 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6825 return -1;
6826 }
6827 j->pld_slicw.pcib.e1 = 1;
6828 outb_p(j->pld_slicw.byte, j->XILINXbase);
6829 break;
6830 case QTI_PHONECARD:
6831 break;
6832 }
6833 }
6834 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6835 if (ixjdebug & 0x0002)
6836 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6837 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6838 return -1;
6839 if (ixjdebug & 0x0002)
6840 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6841 if (j->cardtype == QTI_PHONEJACK) {
6842 cmd = 0x9FF2;
6843 } else {
6844 cmd = 0x9FF5;
6845 }
6846 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6847 return -1;
6848 } else {
6849 if (set_base_frame(j, 30) != 30)
6850 return -1;
6851 if (ixjdebug & 0x0002)
6852 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6853 if (j->cardtype == QTI_PHONECARD) {
6854 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6855 return -1;
6856 }
6857 if (j->cardtype == QTI_LINEJACK) {
6858 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6859 return -1;
6860 if (ixjdebug & 0x0002)
6861 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6862 j->pld_clock.byte = 0;
6863 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6864 }
6865 }
6866
6867 if (j->dsp.low == 0x20) {
6868 if (ixjdebug & 0x0002)
6869 printk(KERN_INFO "Configure GPIO pins\n");
6870 j->gpio.bytes.high = 0x09;
6871 /* bytes.low = 0xEF; 0xF7 */
6872 j->gpio.bits.gpio1 = 1;
6873 j->gpio.bits.gpio2 = 1;
6874 j->gpio.bits.gpio3 = 0;
6875 j->gpio.bits.gpio4 = 1;
6876 j->gpio.bits.gpio5 = 1;
6877 j->gpio.bits.gpio6 = 1;
6878 j->gpio.bits.gpio7 = 1;
6879 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6880 if (ixjdebug & 0x0002)
6881 printk(KERN_INFO "Enable SLIC\n");
6882 j->gpio.bytes.high = 0x0B;
6883 j->gpio.bytes.low = 0x00;
6884 j->gpio.bits.gpio1 = 0;
6885 j->gpio.bits.gpio2 = 1;
6886 j->gpio.bits.gpio5 = 0;
6887 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6888 j->port = PORT_POTS;
6889 } else {
6890 if (j->cardtype == QTI_LINEJACK) {
6891 LED_SetState(0x1, j);
6892 msleep(100);
6893 LED_SetState(0x2, j);
6894 msleep(100);
6895 LED_SetState(0x4, j);
6896 msleep(100);
6897 LED_SetState(0x8, j);
6898 msleep(100);
6899 LED_SetState(0x0, j);
6900 daa_get_version(j);
6901 if (ixjdebug & 0x0002)
6902 printk("Loading DAA Coefficients\n");
6903 DAA_Coeff_US(j);
6904 if (!ixj_daa_write(j)) {
6905 printk("DAA write failed on board %d\n", j->board);
6906 return -1;
6907 }
6908 if(!ixj_daa_cid_reset(j)) {
6909 printk("DAA CID reset failed on board %d\n", j->board);
6910 return -1;
6911 }
6912 j->flags.pots_correct = 0;
6913 j->flags.pstn_present = 0;
6914 ixj_linetest(j);
6915 if (j->flags.pots_correct) {
6916 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6917
6918 outb_p(j->pld_scrw.byte, j->XILINXbase);
6919 j->pld_slicw.bits.rly1 = 1;
6920 j->pld_slicw.bits.spken = 1;
6921 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6922 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6923 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6924 j->port = PORT_POTS;
6925 }
6926 ixj_set_port(j, PORT_PSTN);
6927 ixj_set_pots(j, 1);
6928 if (ixjdebug & 0x0002)
6929 printk(KERN_INFO "Enable Mixer\n");
6930 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6931 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6932
6933 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6934 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6935
6936 ixj_mixer(0x0480, j); /*FM Left mute */
6937 ixj_mixer(0x0580, j); /*FM Right mute */
6938
6939 ixj_mixer(0x0680, j); /*CD Left mute */
6940 ixj_mixer(0x0780, j); /*CD Right mute */
6941
6942 ixj_mixer(0x0880, j); /*Line Left mute */
6943 ixj_mixer(0x0980, j); /*Line Right mute */
6944
6945 ixj_mixer(0x0A80, j); /*Aux left mute */
6946 ixj_mixer(0x0B80, j); /*Aux right mute */
6947
6948 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6949 ixj_mixer(0x0D80, j); /*Mono2 mute */
6950
6951 ixj_mixer(0x0E80, j); /*Mic mute */
6952
6953 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6954
6955 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6956 ixj_mixer(0x110C, j);
6957
6958
6959 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6960 ixj_mixer(0x1401, j);
6961
6962 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6963 ixj_mixer(0x1501, j);
6964
6965 ixj_mixer(0x1700, j); /*Clock select */
6966
6967 ixj_mixer(0x1800, j); /*ADC input from mixer */
6968
6969 ixj_mixer(0x1901, j); /*Mic gain 30db */
6970
6971 if (ixjdebug & 0x0002)
6972 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6973 j->cadence_f[4].state = 0;
6974 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6975 j->cadence_f[4].off1 = 0;
6976 j->cadence_f[4].on2 = 0;
6977 j->cadence_f[4].off2 = 0;
6978 j->cadence_f[4].on3 = 0;
6979 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
6980 j->pstn_last_rmr = jiffies;
6981
6982 } else {
6983 if (j->cardtype == QTI_PHONECARD) {
6984 ixj_WriteDSPCommand(0xCF07, j);
6985 ixj_WriteDSPCommand(0x00B0, j);
6986 ixj_set_port(j, PORT_SPEAKER);
6987 } else {
6988 ixj_set_port(j, PORT_POTS);
6989 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6990 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6991 }
6992 }
6993 }
6994
6995 j->intercom = -1;
6996 j->framesread = j->frameswritten = 0;
6997 j->read_wait = j->write_wait = 0;
6998 j->rxreadycheck = j->txreadycheck = 0;
6999
7000 /* initialise the DTMF prescale to a sensible value */
7001 if (j->cardtype == QTI_LINEJACK) {
7002 set_dtmf_prescale(j, 0x10);
7003 } else {
7004 set_dtmf_prescale(j, 0x40);
7005 }
7006 set_play_volume(j, 0x100);
7007 set_rec_volume(j, 0x100);
7008
7009 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7010 return -1;
7011 /* The read values of the SSR should be 0x00 for the IDLE command */
7012 if (j->ssr.low || j->ssr.high)
7013 return -1;
7014
7015 if (ixjdebug & 0x0002)
7016 printk(KERN_INFO "Enable Line Monitor\n");
7017
7018 if (ixjdebug & 0x0002)
7019 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7020
7021 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7022 return -1;
7023
7024 if (ixjdebug & 0x002)
7025 printk(KERN_INFO "Enable DTMF Detectors\n");
7026
7027 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7028 return -1;
7029
7030 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7031 return -1;
7032
7033 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7034
7035 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7036
7037 j->ex.bits.dtmf_ready = 0;
7038 j->dtmf_state = 0;
7039 j->dtmf_wp = j->dtmf_rp = 0;
7040 j->rec_mode = j->play_mode = -1;
7041 j->flags.ringing = 0;
7042 j->maxrings = MAXRINGS;
7043 j->ring_cadence = USA_RING_CADENCE;
7044 j->drybuffer = 0;
7045 j->winktime = 320;
7046 j->flags.dtmf_oob = 0;
7047 for (cnt = 0; cnt < 4; cnt++)
7048 j->cadence_f[cnt].enable = 0;
7049 /* must be a device on the specified address */
7050 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7051
7052 /* Set up the default signals for events */
7053 for (cnt = 0; cnt < 35; cnt++)
7054 j->ixj_signals[cnt] = SIGIO;
7055
7056 /* Set the excetion signal enable flags */
7057 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7058 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 =
7059 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;
7060 #ifdef IXJ_DYN_ALLOC
7061 j->fskdata = NULL;
7062 #endif
7063 j->fskdcnt = 0;
7064 j->cidcw_wait = 0;
7065
7066 /* Register with the Telephony for Linux subsystem */
7067 j->p.f_op = &ixj_fops;
7068 j->p.open = ixj_open;
7069 j->p.board = j->board;
7070 phone_register_device(&j->p, PHONE_UNIT_ANY);
7071
7072 ixj_init_timer(j);
7073 ixj_add_timer(j);
7074 return 0;
7075 }
7076
7077 /*
7078 * Exported service for pcmcia card handling
7079 */
7080
7081 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7082 {
7083 IXJ *j = ixj_alloc();
7084
7085 j->board = 0;
7086
7087 j->DSPbase = dsp;
7088 j->XILINXbase = xilinx;
7089 j->cardtype = QTI_PHONECARD;
7090 ixj_selfprobe(j);
7091 return j;
7092 }
7093
7094 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7095
7096 static int ixj_get_status_proc(char *buf)
7097 {
7098 int len;
7099 int cnt;
7100 IXJ *j;
7101 len = 0;
7102 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7103 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7104 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7105 len += sprintf(buf + len, "\nUsing old telephony API");
7106 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7107
7108 for (cnt = 0; cnt < IXJMAX; cnt++) {
7109 j = get_ixj(cnt);
7110 if(j==NULL)
7111 continue;
7112 if (j->DSPbase) {
7113 len += sprintf(buf + len, "\nCard Num %d", cnt);
7114 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7115 if (j->cardtype != QTI_PHONEJACK)
7116 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7117 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7118 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7119 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7120 switch (j->cardtype) {
7121 case (QTI_PHONEJACK):
7122 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7123 break;
7124 case (QTI_LINEJACK):
7125 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7126 if (j->flags.g729_loaded)
7127 len += sprintf(buf + len, " w/G.729 A/B");
7128 len += sprintf(buf + len, " Country = %d", j->daa_country);
7129 break;
7130 case (QTI_PHONEJACK_LITE):
7131 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7132 if (j->flags.g729_loaded)
7133 len += sprintf(buf + len, " w/G.729 A/B");
7134 break;
7135 case (QTI_PHONEJACK_PCI):
7136 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7137 if (j->flags.g729_loaded)
7138 len += sprintf(buf + len, " w/G.729 A/B");
7139 break;
7140 case (QTI_PHONECARD):
7141 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7142 if (j->flags.g729_loaded)
7143 len += sprintf(buf + len, " w/G.729 A/B");
7144 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7145 if (!j->pccr1.bits.drf)
7146 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7147 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7148 break;
7149 default:
7150 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7151 break;
7152 }
7153 len += sprintf(buf + len, "\nReaders %d", j->readers);
7154 len += sprintf(buf + len, "\nWriters %d", j->writers);
7155 add_caps(j);
7156 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7157 if (j->dsp.low != 0x20)
7158 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7159 if (j->flags.cidsent)
7160 len += sprintf(buf + len, "\nCaller ID data sent");
7161 else
7162 len += sprintf(buf + len, "\nCaller ID data not sent");
7163
7164 len += sprintf(buf + len, "\nPlay CODEC ");
7165 switch (j->play_codec) {
7166 case G723_63:
7167 len += sprintf(buf + len, "G.723.1 6.3");
7168 break;
7169 case G723_53:
7170 len += sprintf(buf + len, "G.723.1 5.3");
7171 break;
7172 case TS85:
7173 len += sprintf(buf + len, "TrueSpeech 8.5");
7174 break;
7175 case TS48:
7176 len += sprintf(buf + len, "TrueSpeech 4.8");
7177 break;
7178 case TS41:
7179 len += sprintf(buf + len, "TrueSpeech 4.1");
7180 break;
7181 case G728:
7182 len += sprintf(buf + len, "G.728");
7183 break;
7184 case G729:
7185 len += sprintf(buf + len, "G.729");
7186 break;
7187 case G729B:
7188 len += sprintf(buf + len, "G.729B");
7189 break;
7190 case ULAW:
7191 len += sprintf(buf + len, "uLaw");
7192 break;
7193 case ALAW:
7194 len += sprintf(buf + len, "aLaw");
7195 break;
7196 case LINEAR16:
7197 len += sprintf(buf + len, "16 bit Linear");
7198 break;
7199 case LINEAR8:
7200 len += sprintf(buf + len, "8 bit Linear");
7201 break;
7202 case WSS:
7203 len += sprintf(buf + len, "Windows Sound System");
7204 break;
7205 default:
7206 len += sprintf(buf + len, "NO CODEC CHOSEN");
7207 break;
7208 }
7209 len += sprintf(buf + len, "\nRecord CODEC ");
7210 switch (j->rec_codec) {
7211 case G723_63:
7212 len += sprintf(buf + len, "G.723.1 6.3");
7213 break;
7214 case G723_53:
7215 len += sprintf(buf + len, "G.723.1 5.3");
7216 break;
7217 case TS85:
7218 len += sprintf(buf + len, "TrueSpeech 8.5");
7219 break;
7220 case TS48:
7221 len += sprintf(buf + len, "TrueSpeech 4.8");
7222 break;
7223 case TS41:
7224 len += sprintf(buf + len, "TrueSpeech 4.1");
7225 break;
7226 case G728:
7227 len += sprintf(buf + len, "G.728");
7228 break;
7229 case G729:
7230 len += sprintf(buf + len, "G.729");
7231 break;
7232 case G729B:
7233 len += sprintf(buf + len, "G.729B");
7234 break;
7235 case ULAW:
7236 len += sprintf(buf + len, "uLaw");
7237 break;
7238 case ALAW:
7239 len += sprintf(buf + len, "aLaw");
7240 break;
7241 case LINEAR16:
7242 len += sprintf(buf + len, "16 bit Linear");
7243 break;
7244 case LINEAR8:
7245 len += sprintf(buf + len, "8 bit Linear");
7246 break;
7247 case WSS:
7248 len += sprintf(buf + len, "Windows Sound System");
7249 break;
7250 default:
7251 len += sprintf(buf + len, "NO CODEC CHOSEN");
7252 break;
7253 }
7254 len += sprintf(buf + len, "\nAEC ");
7255 switch (j->aec_level) {
7256 case AEC_OFF:
7257 len += sprintf(buf + len, "Off");
7258 break;
7259 case AEC_LOW:
7260 len += sprintf(buf + len, "Low");
7261 break;
7262 case AEC_MED:
7263 len += sprintf(buf + len, "Med");
7264 break;
7265 case AEC_HIGH:
7266 len += sprintf(buf + len, "High");
7267 break;
7268 case AEC_AUTO:
7269 len += sprintf(buf + len, "Auto");
7270 break;
7271 case AEC_AGC:
7272 len += sprintf(buf + len, "AEC/AGC");
7273 break;
7274 default:
7275 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7276 break;
7277 }
7278
7279 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7280 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7281 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7282
7283 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7284
7285 if (j->cardtype == QTI_LINEJACK) {
7286 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7287 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7288 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7289 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7290 switch (j->daa_mode) {
7291 case SOP_PU_SLEEP:
7292 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7293 break;
7294 case SOP_PU_RINGING:
7295 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7296 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7297 break;
7298 case SOP_PU_CONVERSATION:
7299 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7300 break;
7301 case SOP_PU_PULSEDIALING:
7302 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7303 break;
7304 }
7305 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7306 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7307 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7308 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7309 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7310 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7311 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7312 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7313 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7314 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7315 }
7316 switch (j->port) {
7317 case PORT_POTS:
7318 len += sprintf(buf + len, "\nPort POTS");
7319 break;
7320 case PORT_PSTN:
7321 len += sprintf(buf + len, "\nPort PSTN");
7322 break;
7323 case PORT_SPEAKER:
7324 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7325 break;
7326 case PORT_HANDSET:
7327 len += sprintf(buf + len, "\nPort HANDSET");
7328 break;
7329 }
7330 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7331 len += sprintf(buf + len, "\nSLIC state ");
7332 switch (SLIC_GetState(j)) {
7333 case PLD_SLIC_STATE_OC:
7334 len += sprintf(buf + len, "OC");
7335 break;
7336 case PLD_SLIC_STATE_RINGING:
7337 len += sprintf(buf + len, "RINGING");
7338 break;
7339 case PLD_SLIC_STATE_ACTIVE:
7340 len += sprintf(buf + len, "ACTIVE");
7341 break;
7342 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7343 len += sprintf(buf + len, "OHT");
7344 break;
7345 case PLD_SLIC_STATE_TIPOPEN:
7346 len += sprintf(buf + len, "TIPOPEN");
7347 break;
7348 case PLD_SLIC_STATE_STANDBY:
7349 len += sprintf(buf + len, "STANDBY");
7350 break;
7351 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7352 len += sprintf(buf + len, "APR");
7353 break;
7354 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7355 len += sprintf(buf + len, "OHTPR");
7356 break;
7357 default:
7358 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7359 break;
7360 }
7361 }
7362 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7363 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7364 #ifdef PERFMON_STATS
7365 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7366 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7367 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7368 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7369 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7370 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7371 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7372 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7373 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7374 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7375 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7376 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7377 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7378 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7379
7380 #endif
7381 len += sprintf(buf + len, "\n");
7382 }
7383 }
7384 return len;
7385 }
7386
7387 static int ixj_read_proc(char *page, char **start, off_t off,
7388 int count, int *eof, void *data)
7389 {
7390 int len = ixj_get_status_proc(page);
7391 if (len <= off+count) *eof = 1;
7392 *start = page + off;
7393 len -= off;
7394 if (len>count) len = count;
7395 if (len<0) len = 0;
7396 return len;
7397 }
7398
7399
7400 static void cleanup(void)
7401 {
7402 int cnt;
7403 IXJ *j;
7404
7405 for (cnt = 0; cnt < IXJMAX; cnt++) {
7406 j = get_ixj(cnt);
7407 if(j != NULL && j->DSPbase) {
7408 if (ixjdebug & 0x0002)
7409 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7410 del_timer(&j->timer);
7411 if (j->cardtype == QTI_LINEJACK) {
7412 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7413
7414 outb_p(j->pld_scrw.byte, j->XILINXbase);
7415 j->pld_slicw.bits.rly1 = 0;
7416 j->pld_slicw.bits.rly2 = 0;
7417 j->pld_slicw.bits.rly3 = 0;
7418 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7419 LED_SetState(0x0, j);
7420 if (ixjdebug & 0x0002)
7421 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7422 release_region(j->XILINXbase, 8);
7423 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7424 if (ixjdebug & 0x0002)
7425 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7426 release_region(j->XILINXbase, 4);
7427 }
7428 kfree(j->read_buffer);
7429 kfree(j->write_buffer);
7430 if (j->dev)
7431 pnp_device_detach(j->dev);
7432 if (ixjdebug & 0x0002)
7433 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7434 phone_unregister_device(&j->p);
7435 if (ixjdebug & 0x0002)
7436 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7437 release_region(j->DSPbase, 16);
7438 #ifdef IXJ_DYN_ALLOC
7439 if (ixjdebug & 0x0002)
7440 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7441 kfree(j);
7442 ixj[cnt] = NULL;
7443 #endif
7444 }
7445 }
7446 if (ixjdebug & 0x0002)
7447 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7448 remove_proc_entry ("ixj", NULL);
7449 }
7450
7451 /* Typedefs */
7452 typedef struct {
7453 BYTE length;
7454 DWORD bits;
7455 } DATABLOCK;
7456
7457 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7458 {
7459 lastLCC = lastLCC & 0xfb;
7460 lastLCC = lastLCC | (byData ? 4 : 0);
7461 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7462
7463 mdelay(1);
7464 lastLCC = lastLCC | 0x01;
7465 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7466
7467 byData = byData << 1;
7468 lastLCC = lastLCC & 0xfe;
7469 mdelay(1);
7470 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7471
7472 }
7473
7474 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7475 {
7476 mdelay(1);
7477 lastLCC = lastLCC | 0x01;
7478 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7479
7480 lastLCC = lastLCC & 0xfe;
7481 mdelay(1);
7482 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7483
7484 return ((inb(wEEPROMAddress) >> 3) & 1);
7485 }
7486
7487 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7488 {
7489 BYTE lastLCC;
7490 WORD wEEPROMAddress = wAddress + 3;
7491 DWORD i;
7492 BYTE byResult;
7493 *pwResult = 0;
7494 lastLCC = inb(wEEPROMAddress);
7495 lastLCC = lastLCC | 0x02;
7496 lastLCC = lastLCC & 0xfe;
7497 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7498
7499 mdelay(1); /* delay */
7500
7501 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7502 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7503 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7504 for (i = 0; i < 8; i++) {
7505 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7506 wLoc <<= 1;
7507 }
7508
7509 for (i = 0; i < 16; i++) {
7510 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7511 *pwResult = (*pwResult << 1) | byResult;
7512 }
7513
7514 mdelay(1); /* another delay */
7515
7516 lastLCC = lastLCC & 0xfd;
7517 outb(lastLCC, wEEPROMAddress); /* negate CS */
7518
7519 return 0;
7520 }
7521
7522 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7523 {
7524 WORD wLo, wHi;
7525 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7526 return 0;
7527 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7528 return 0;
7529 return (((DWORD) wHi << 16) | wLo);
7530 }
7531
7532 static int dspio[IXJMAX + 1] =
7533 {
7534 0,
7535 };
7536 static int xio[IXJMAX + 1] =
7537 {
7538 0,
7539 };
7540
7541 module_param_array(dspio, int, NULL, 0);
7542 module_param_array(xio, int, NULL, 0);
7543 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7544 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7545 MODULE_LICENSE("GPL");
7546
7547 static void __exit ixj_exit(void)
7548 {
7549 cleanup();
7550 }
7551
7552 static IXJ *new_ixj(unsigned long port)
7553 {
7554 IXJ *res;
7555 if (!request_region(port, 16, "ixj DSP")) {
7556 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7557 return NULL;
7558 }
7559 res = ixj_alloc();
7560 if (!res) {
7561 release_region(port, 16);
7562 printk(KERN_INFO "ixj: out of memory\n");
7563 return NULL;
7564 }
7565 res->DSPbase = port;
7566 return res;
7567 }
7568
7569 static int __init ixj_probe_isapnp(int *cnt)
7570 {
7571 int probe = 0;
7572 int func = 0x110;
7573 struct pnp_dev *dev = NULL, *old_dev = NULL;
7574
7575 while (1) {
7576 do {
7577 IXJ *j;
7578 int result;
7579
7580 old_dev = dev;
7581 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7582 ISAPNP_FUNCTION(func), old_dev);
7583 if (!dev || !dev->card)
7584 break;
7585 result = pnp_device_attach(dev);
7586 if (result < 0) {
7587 printk("pnp attach failed %d \n", result);
7588 break;
7589 }
7590 if (pnp_activate_dev(dev) < 0) {
7591 printk("pnp activate failed (out of resources?)\n");
7592 pnp_device_detach(dev);
7593 return -ENOMEM;
7594 }
7595
7596 if (!pnp_port_valid(dev, 0)) {
7597 pnp_device_detach(dev);
7598 return -ENODEV;
7599 }
7600
7601 j = new_ixj(pnp_port_start(dev, 0));
7602 if (!j)
7603 break;
7604
7605 if (func != 0x110)
7606 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7607
7608 switch (func) {
7609 case (0x110):
7610 j->cardtype = QTI_PHONEJACK;
7611 break;
7612 case (0x310):
7613 j->cardtype = QTI_LINEJACK;
7614 break;
7615 case (0x410):
7616 j->cardtype = QTI_PHONEJACK_LITE;
7617 break;
7618 }
7619 j->board = *cnt;
7620 probe = ixj_selfprobe(j);
7621 if(!probe) {
7622 j->serial = dev->card->serial;
7623 j->dev = dev;
7624 switch (func) {
7625 case 0x110:
7626 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7627 break;
7628 case 0x310:
7629 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7630 break;
7631 case 0x410:
7632 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7633 break;
7634 }
7635 }
7636 ++*cnt;
7637 } while (dev);
7638 if (func == 0x410)
7639 break;
7640 if (func == 0x310)
7641 func = 0x410;
7642 if (func == 0x110)
7643 func = 0x310;
7644 dev = NULL;
7645 }
7646 return probe;
7647 }
7648
7649 static int __init ixj_probe_isa(int *cnt)
7650 {
7651 int i, probe;
7652
7653 /* Use passed parameters for older kernels without PnP */
7654 for (i = 0; i < IXJMAX; i++) {
7655 if (dspio[i]) {
7656 IXJ *j = new_ixj(dspio[i]);
7657
7658 if (!j)
7659 break;
7660
7661 j->XILINXbase = xio[i];
7662 j->cardtype = 0;
7663
7664 j->board = *cnt;
7665 probe = ixj_selfprobe(j);
7666 j->dev = NULL;
7667 ++*cnt;
7668 }
7669 }
7670 return 0;
7671 }
7672
7673 static int __init ixj_probe_pci(int *cnt)
7674 {
7675 struct pci_dev *pci = NULL;
7676 int i, probe = 0;
7677 IXJ *j = NULL;
7678
7679 for (i = 0; i < IXJMAX - *cnt; i++) {
7680 pci = pci_find_device(0x15E2, 0x0500, pci);
7681 if (!pci)
7682 break;
7683
7684 if (pci_enable_device(pci))
7685 break;
7686 j = new_ixj(pci_resource_start(pci, 0));
7687 if (!j)
7688 break;
7689
7690 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7691 j->XILINXbase = j->DSPbase + 0x10;
7692 j->cardtype = QTI_PHONEJACK_PCI;
7693 j->board = *cnt;
7694 probe = ixj_selfprobe(j);
7695 if (!probe)
7696 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7697 ++*cnt;
7698 }
7699 return probe;
7700 }
7701
7702 static int __init ixj_init(void)
7703 {
7704 int cnt = 0;
7705 int probe = 0;
7706
7707 cnt = 0;
7708
7709 /* These might be no-ops, see above. */
7710 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7711 return probe;
7712 }
7713 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7714 return probe;
7715 }
7716 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7717 return probe;
7718 }
7719 printk(KERN_INFO "ixj driver initialized.\n");
7720 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7721 return probe;
7722 }
7723
7724 module_init(ixj_init);
7725 module_exit(ixj_exit);
7726
7727 static void DAA_Coeff_US(IXJ *j)
7728 {
7729 int i;
7730
7731 j->daa_country = DAA_US;
7732 /*----------------------------------------------- */
7733 /* CAO */
7734 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7735 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7736 }
7737
7738 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7739 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7740 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7741 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7742 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7743 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7744 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7745 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7746 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7747 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7748 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7749 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7750 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7751 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7752 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7753 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7754 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7755 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7756 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7757 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7758 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7759 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7760 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7761 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7762 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7763 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7764 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7765 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7766 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7767 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7768 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7769 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7770 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7771 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7772 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7773 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7774 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7775 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7776 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7777 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7778 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7779 /* Bytes for AR-filter (09): 52,D3,11,42 */
7780 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7781 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7782 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7783 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7784 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7785 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7786 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7787 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7788 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7789 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7790 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7791 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7792 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7793 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7794 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7795 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7796 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7797 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7798 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7799 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7800 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7801 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7802 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7803 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7804 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7805 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7806 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7807 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7811 /* ; (10K, 0.68uF) */
7812 /* */
7813 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7814 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7815 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7816 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7817 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7818 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7819 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7820 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7821 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7822 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7823 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7824 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7825 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7826 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7827 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7828 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7829 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7830 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7831
7832 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7833 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7834 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7835 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7836 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7837
7838 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7839 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7840 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7841 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7842 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7843 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7844 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7845 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7846 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7847 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7848 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7849 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7850 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7851 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7852 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7853 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7854 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7855 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7856 /* */
7857 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7858 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7859 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7860 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7861 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7862
7863 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7864 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7865 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7866 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7867 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7868 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7869 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7870 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7871 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7872 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7873 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7874 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7875 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7876 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7877 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7878 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7879 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7880 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7881 /* */
7882 /* ;CR Registers */
7883 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7884 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7885 /* Config. Reg. 1 (dialing) (cr1):05 */
7886 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7887 /* Config. Reg. 2 (caller ID) (cr2):04 */
7888 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7889 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7890 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7891 /* Config. Reg. 4 (analog gain) (cr4):02 */
7892 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7893 /* Config. Reg. 5 (Version) (cr5):02 */
7894 /* Config. Reg. 6 (Reserved) (cr6):00 */
7895 /* Config. Reg. 7 (Reserved) (cr7):00 */
7896 /* */
7897 /* ;xr Registers */
7898 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7899
7900 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7901 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7902
7903 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7904 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7905 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7906 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7907 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7908 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7909
7910 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7911 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7912 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7913 /* Ext. Reg. 6 (Power State) (xr6):00 */
7914 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7915 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7916 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7917 /* */
7918 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7919 /* 12,33,5A,C3 ; 770 Hz */
7920 /* 13,3C,5B,32 ; 852 Hz */
7921 /* 1D,1B,5C,CC ; 941 Hz */
7922
7923 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7924 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7925 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7926 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7927 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7928 /* EC,1D,52,22 ; 1336 Hz */
7929 /* AA,AC,51,D2 ; 1477 Hz */
7930 /* 9B,3B,51,25 ; 1633 Hz */
7931 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7932 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7933 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7934 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7935 }
7936
7937 static void DAA_Coeff_UK(IXJ *j)
7938 {
7939 int i;
7940
7941 j->daa_country = DAA_UK;
7942 /*----------------------------------------------- */
7943 /* CAO */
7944 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7945 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7946 }
7947
7948 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7949 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7950 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7951 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7952 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7953 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7954 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7955 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7956 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7957 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7958 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7959 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7960 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7961 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7962 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7963 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7964 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7965 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7966 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7967 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7968 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7969 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7970 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7971 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7972 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7973 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7974 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7975 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7976 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7977 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7978 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7979 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7980 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7981 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
7982 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
7983 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7984 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
7985 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
7986 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
7987 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7988 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7989 /* Bytes for AR-filter (09): E2,27,10,D6 */
7990 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
7991 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
7992 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7993 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7994 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
7995 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
7996 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
7997 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
7998 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
7999 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8000 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8001 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8002 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8003 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8004 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8005 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8006 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8007 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8008 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8009 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8010 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8011 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8012 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8013 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8014 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8015 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8016 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8017 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8018 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8021 /* ; idle */
8022 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8023 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8024 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8025 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8026 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8027 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8028 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8029 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8030 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8031 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8032 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8033 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8034 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8035 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8036 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8037 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8038 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8039 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8040 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8041 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8042 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8043 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8044 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8045 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8046 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8047 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8048 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8049 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8050 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8051 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8052 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8053 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8054 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8055 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8056 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8057 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8058 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8059 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8060 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8061 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8062 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8063 /* ;CR Registers */
8064 /* Config. Reg. 0 (filters) (cr0):FF */
8065 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8066 /* Config. Reg. 1 (dialing) (cr1):05 */
8067 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8068 /* Config. Reg. 2 (caller ID) (cr2):04 */
8069 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8070 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8071 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8072 /* Config. Reg. 4 (analog gain) (cr4):02 */
8073 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8074 /* Config. Reg. 5 (Version) (cr5):02 */
8075 /* Config. Reg. 6 (Reserved) (cr6):00 */
8076 /* Config. Reg. 7 (Reserved) (cr7):00 */
8077 /* ;xr Registers */
8078 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8079
8080 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8081 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8082
8083 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8084 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8085
8086 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8087 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8088 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8089 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8090 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8091 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8092 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8093 /* Ext. Reg. 6 (Power State) (xr6):00 */
8094 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8095 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8096 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8097 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8098 /* 12,33,5A,C3 ; 770 Hz */
8099 /* 13,3C,5B,32 ; 852 Hz */
8100 /* 1D,1B,5C,CC ; 941 Hz */
8101
8102 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8103 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8104 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8105 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8106 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8107 /* EC,1D,52,22 ; 1336 Hz */
8108 /* AA,AC,51,D2 ; 1477 Hz */
8109 /* 9B,3B,51,25 ; 1633 Hz */
8110 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8111 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8112 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8113 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8114 }
8115
8116
8117 static void DAA_Coeff_France(IXJ *j)
8118 {
8119 int i;
8120
8121 j->daa_country = DAA_FRANCE;
8122 /*----------------------------------------------- */
8123 /* CAO */
8124 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8125 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8126 }
8127
8128 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8129 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8130 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8131 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8132 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8133 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8134 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8135 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8136 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8137 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8138 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8139 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8140 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8141 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8142 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8143 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8144 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8145 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8146 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8147 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8148 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8149 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8150 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8151 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8152 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8153 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8154 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8155 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8156 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8157 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8158 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8159 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8160 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8161 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8162 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8163 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8164 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8165 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8166 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8167 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8168 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8169 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8170 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8171 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8172 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8173 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8174 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8175 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8176 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8177 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8178 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8179 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8180 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8181 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8182 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8183 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8184 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8185 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8186 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8187 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8188 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8189 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8190 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8191 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8192 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8193 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8194 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8195 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8196 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8197 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8198 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8201 /* ; idle */
8202 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8203 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8204 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8205 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8206 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8207 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8208 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8209 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8210 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8211 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8212 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8213 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8214 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8215 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8216 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8217 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8218 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8219 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8220 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8221 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8222 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8223 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8224 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8225 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8226 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8227 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8228 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8229 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8230 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8231 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8232 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8233 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8234 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8235 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8236 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8237 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8238 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8239 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8240 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8241 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8242 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8243 /* ;CR Registers */
8244 /* Config. Reg. 0 (filters) (cr0):FF */
8245 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8246 /* Config. Reg. 1 (dialing) (cr1):05 */
8247 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8248 /* Config. Reg. 2 (caller ID) (cr2):04 */
8249 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8250 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8251 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8252 /* Config. Reg. 4 (analog gain) (cr4):02 */
8253 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8254 /* Config. Reg. 5 (Version) (cr5):02 */
8255 /* Config. Reg. 6 (Reserved) (cr6):00 */
8256 /* Config. Reg. 7 (Reserved) (cr7):00 */
8257 /* ;xr Registers */
8258 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8259
8260 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8261 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8262
8263 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8264 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8265
8266 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8267 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8268 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8269 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8270 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8271 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8272 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8273 /* Ext. Reg. 6 (Power State) (xr6):00 */
8274 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8275 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8276 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8277 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8278 /* 12,33,5A,C3 ; 770 Hz */
8279 /* 13,3C,5B,32 ; 852 Hz */
8280 /* 1D,1B,5C,CC ; 941 Hz */
8281
8282 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8283 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8284 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8285 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8286 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8287 /* EC,1D,52,22 ; 1336 Hz */
8288 /* AA,AC,51,D2 ; 1477 Hz */
8289 /* 9B,3B,51,25 ; 1633 Hz */
8290 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8291 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8292 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8293 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8294 }
8295
8296
8297 static void DAA_Coeff_Germany(IXJ *j)
8298 {
8299 int i;
8300
8301 j->daa_country = DAA_GERMANY;
8302 /*----------------------------------------------- */
8303 /* CAO */
8304 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8305 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8306 }
8307
8308 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8309 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8310 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8311 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8312 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8313 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8314 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8315 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8316 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8317 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8318 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8319 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8320 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8321 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8322 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8323 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8324 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8325 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8326 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8327 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8328 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8329 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8330 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8331 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8332 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8333 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8334 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8335 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8336 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8337 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8338 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8339 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8340 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8341 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8342 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8343 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8344 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8345 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8346 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8347 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8348 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8349 /* Bytes for AR-filter (09): 72,42,13,4B */
8350 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8351 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8352 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8353 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8354 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8355 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8356 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8357 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8358 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8359 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8360 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8361 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8362 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8363 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8364 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8365 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8366 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8367 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8368 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8369 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8370 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8371 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8372 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8373 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8374 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8375 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8376 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8377 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8378 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8381 /* ; (10K, 0.68uF) */
8382 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8383 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8384 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8385 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8386 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8387 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8388 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8389 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8390 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8391 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8392 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8393 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8394 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8395 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8396 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8397 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8398 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8399 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8400 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8401 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8402 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8403 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8404 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8405 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8406 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8407 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8408 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8409 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8410 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8411 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8412 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8413 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8414 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8415 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8416 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8417 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8418 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8419 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8420 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8421 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8422 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8423 /* ;CR Registers */
8424 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8425 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8426 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8427 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8428 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8429 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8430 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8431 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8432 /* Config. Reg. 4 (analog gain) (cr4):02 */
8433 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8434 /* Config. Reg. 5 (Version) (cr5):02 */
8435 /* Config. Reg. 6 (Reserved) (cr6):00 */
8436 /* Config. Reg. 7 (Reserved) (cr7):00 */
8437 /* ;xr Registers */
8438 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8439
8440 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8441 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8442
8443 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8444 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8445
8446 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8447 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8448 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8449 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8450 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8451 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8452 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8453 /* Ext. Reg. 6 (Power State) (xr6):00 */
8454 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8455 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8456 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8457 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8458 /* 12,33,5A,C3 ; 770 Hz */
8459 /* 13,3C,5B,32 ; 852 Hz */
8460 /* 1D,1B,5C,CC ; 941 Hz */
8461
8462 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8463 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8464 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8465 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8466 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8467 /* EC,1D,52,22 ; 1336 Hz */
8468 /* AA,AC,51,D2 ; 1477 Hz */
8469 /* 9B,3B,51,25 ; 1633 Hz */
8470 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8471 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8472 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8473 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8474 }
8475
8476
8477 static void DAA_Coeff_Australia(IXJ *j)
8478 {
8479 int i;
8480
8481 j->daa_country = DAA_AUSTRALIA;
8482 /*----------------------------------------------- */
8483 /* CAO */
8484 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8485 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8486 }
8487
8488 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8489 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8490 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8491 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8492 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8493 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8494 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8495 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8496 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8497 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8498 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8499 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8500 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8501 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8502 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8503 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8504 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8505 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8506 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8507 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8508 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8509 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8510 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8511 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8512 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8513 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8514 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8515 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8516 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8517 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8518 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8519 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8520 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8521 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8522 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8523 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8524 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8525 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8526 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8527 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8528 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8529 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8530 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8531 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8532 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8533 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8534 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8535 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8536 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8537 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8538 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8539 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8540 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8541 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8542 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8543 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8544 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8545 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8546 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8547 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8548 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8549 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8550 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8551 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8552 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8553 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8554 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8555 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8556 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8557 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8558 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8561 /* ; idle */
8562 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8563 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8564 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8565 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8566 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8567 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8568 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8569 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8570 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8571 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8572 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8573 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8574 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8575 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8576 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8577 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8578 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8579 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8580 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8581 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8582 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8583 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8584 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8585 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8586 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8587 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8588 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8589 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8590 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8591 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8592 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8593 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8594 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8595 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8596 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8597 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8598 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8599 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8600 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8601 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8602 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8603 /* ;CR Registers */
8604 /* Config. Reg. 0 (filters) (cr0):FF */
8605 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8606 /* Config. Reg. 1 (dialing) (cr1):05 */
8607 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8608 /* Config. Reg. 2 (caller ID) (cr2):04 */
8609 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8610 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8611 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8612 /* Config. Reg. 4 (analog gain) (cr4):02 */
8613 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8614 /* Config. Reg. 5 (Version) (cr5):02 */
8615 /* Config. Reg. 6 (Reserved) (cr6):00 */
8616 /* Config. Reg. 7 (Reserved) (cr7):00 */
8617 /* ;xr Registers */
8618 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8619
8620 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8621 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8622
8623 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8624 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8625
8626 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8627 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8628 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8629 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8630 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8631 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8632 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8633 /* Ext. Reg. 6 (Power State) (xr6):00 */
8634 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8635 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8636 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8637
8638 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8639 /* 12,33,5A,C3 ; 770 Hz */
8640 /* 13,3C,5B,32 ; 852 Hz */
8641 /* 1D,1B,5C,CC ; 941 Hz */
8642 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8643 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8644 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8645 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8646
8647 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8648 /* EC,1D,52,22 ; 1336 Hz */
8649 /* AA,AC,51,D2 ; 1477 Hz */
8650 /* 9B,3B,51,25 ; 1633 Hz */
8651 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8652 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8653 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8654 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8655 }
8656
8657 static void DAA_Coeff_Japan(IXJ *j)
8658 {
8659 int i;
8660
8661 j->daa_country = DAA_JAPAN;
8662 /*----------------------------------------------- */
8663 /* CAO */
8664 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8665 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8666 }
8667
8668 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8669 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8670 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8671 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8672 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8673 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8674 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8675 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8676 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8677 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8678 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8679 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8680 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8681 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8682 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8683 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8684 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8685 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8686 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8687 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8688 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8689 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8690 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8691 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8692 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8693 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8694 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8695 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8696 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8697 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8698 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8699 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8700 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8701 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8702 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8703 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8704 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8705 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8706 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8707 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8708 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8709 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8710 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8711 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8712 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8713 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8714 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8715 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8716 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8717 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8718 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8719 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8720 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8721 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8722 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8723 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8724 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8725 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8726 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8727 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8728 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8729 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8730 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8731 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8732 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8733 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8734 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8735 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8736 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8737 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8738 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8741 /* ; idle */
8742 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8743 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8744 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8745 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8746 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8747 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8748 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8749 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8750 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8751 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8752 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8753 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8754 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8755 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8756 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8757 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8758 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8759 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8760 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8761 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8762 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8763 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8764 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8765 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8766 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8767 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8768 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8769 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8770 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8771 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8772 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8773 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8774 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8775 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8776 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8777 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8778 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8779 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8780 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8781 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8782 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8783 /* ;CR Registers */
8784 /* Config. Reg. 0 (filters) (cr0):FF */
8785 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8786 /* Config. Reg. 1 (dialing) (cr1):05 */
8787 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8788 /* Config. Reg. 2 (caller ID) (cr2):04 */
8789 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8790 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8791 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8792 /* Config. Reg. 4 (analog gain) (cr4):02 */
8793 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8794 /* Config. Reg. 5 (Version) (cr5):02 */
8795 /* Config. Reg. 6 (Reserved) (cr6):00 */
8796 /* Config. Reg. 7 (Reserved) (cr7):00 */
8797 /* ;xr Registers */
8798 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8799
8800 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8801 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8802
8803 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8804 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8805
8806 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8807 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8808 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8809 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8810 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8811 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8812 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8813 /* Ext. Reg. 6 (Power State) (xr6):00 */
8814 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8815 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8816 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8817 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8818 /* 12,33,5A,C3 ; 770 Hz */
8819 /* 13,3C,5B,32 ; 852 Hz */
8820 /* 1D,1B,5C,CC ; 941 Hz */
8821
8822 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8823 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8824 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8825 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8826 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8827 /* EC,1D,52,22 ; 1336 Hz */
8828 /* AA,AC,51,D2 ; 1477 Hz */
8829 /* 9B,3B,51,25 ; 1633 Hz */
8830 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8831 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8832 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8833 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8834 }
8835
8836 static s16 tone_table[][19] =
8837 {
8838 { /* f20_50[] 11 */
8839 32538, /* A1 = 1.985962 */
8840 -32325, /* A2 = -0.986511 */
8841 -343, /* B2 = -0.010493 */
8842 0, /* B1 = 0 */
8843 343, /* B0 = 0.010493 */
8844 32619, /* A1 = 1.990906 */
8845 -32520, /* A2 = -0.992462 */
8846 19179, /* B2 = 0.585327 */
8847 -19178, /* B1 = -1.170593 */
8848 19179, /* B0 = 0.585327 */
8849 32723, /* A1 = 1.997314 */
8850 -32686, /* A2 = -0.997528 */
8851 9973, /* B2 = 0.304352 */
8852 -9955, /* B1 = -0.607605 */
8853 9973, /* B0 = 0.304352 */
8854 7, /* Internal filter scaling */
8855 159, /* Minimum in-band energy threshold */
8856 21, /* 21/32 in-band to broad-band ratio */
8857 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8858 },
8859 { /* f133_200[] 12 */
8860 32072, /* A1 = 1.95752 */
8861 -31896, /* A2 = -0.973419 */
8862 -435, /* B2 = -0.013294 */
8863 0, /* B1 = 0 */
8864 435, /* B0 = 0.013294 */
8865 32188, /* A1 = 1.9646 */
8866 -32400, /* A2 = -0.98877 */
8867 15139, /* B2 = 0.462036 */
8868 -14882, /* B1 = -0.908356 */
8869 15139, /* B0 = 0.462036 */
8870 32473, /* A1 = 1.981995 */
8871 -32524, /* A2 = -0.992584 */
8872 23200, /* B2 = 0.708008 */
8873 -23113, /* B1 = -1.410706 */
8874 23200, /* B0 = 0.708008 */
8875 7, /* Internal filter scaling */
8876 159, /* Minimum in-band energy threshold */
8877 21, /* 21/32 in-band to broad-band ratio */
8878 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8879 },
8880 { /* f300 13 */
8881 31769, /* A1 = -1.939026 */
8882 -32584, /* A2 = 0.994385 */
8883 -475, /* B2 = -0.014522 */
8884 0, /* B1 = 0.000000 */
8885 475, /* B0 = 0.014522 */
8886 31789, /* A1 = -1.940247 */
8887 -32679, /* A2 = 0.997284 */
8888 17280, /* B2 = 0.527344 */
8889 -16865, /* B1 = -1.029358 */
8890 17280, /* B0 = 0.527344 */
8891 31841, /* A1 = -1.943481 */
8892 -32681, /* A2 = 0.997345 */
8893 543, /* B2 = 0.016579 */
8894 -525, /* B1 = -0.032097 */
8895 543, /* B0 = 0.016579 */
8896 5, /* Internal filter scaling */
8897 159, /* Minimum in-band energy threshold */
8898 21, /* 21/32 in-band to broad-band ratio */
8899 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8900 },
8901 { /* f300_420[] 14 */
8902 30750, /* A1 = 1.876892 */
8903 -31212, /* A2 = -0.952515 */
8904 -804, /* B2 = -0.024541 */
8905 0, /* B1 = 0 */
8906 804, /* B0 = 0.024541 */
8907 30686, /* A1 = 1.872925 */
8908 -32145, /* A2 = -0.980988 */
8909 14747, /* B2 = 0.450043 */
8910 -13703, /* B1 = -0.836395 */
8911 14747, /* B0 = 0.450043 */
8912 31651, /* A1 = 1.931824 */
8913 -32321, /* A2 = -0.986389 */
8914 24425, /* B2 = 0.745422 */
8915 -23914, /* B1 = -1.459595 */
8916 24427, /* B0 = 0.745483 */
8917 7, /* Internal filter scaling */
8918 159, /* Minimum in-band energy threshold */
8919 21, /* 21/32 in-band to broad-band ratio */
8920 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8921 },
8922 { /* f330 15 */
8923 31613, /* A1 = -1.929565 */
8924 -32646, /* A2 = 0.996277 */
8925 -185, /* B2 = -0.005657 */
8926 0, /* B1 = 0.000000 */
8927 185, /* B0 = 0.005657 */
8928 31620, /* A1 = -1.929932 */
8929 -32713, /* A2 = 0.998352 */
8930 19253, /* B2 = 0.587585 */
8931 -18566, /* B1 = -1.133179 */
8932 19253, /* B0 = 0.587585 */
8933 31674, /* A1 = -1.933228 */
8934 -32715, /* A2 = 0.998413 */
8935 2575, /* B2 = 0.078590 */
8936 -2495, /* B1 = -0.152283 */
8937 2575, /* B0 = 0.078590 */
8938 5, /* Internal filter scaling */
8939 159, /* Minimum in-band energy threshold */
8940 21, /* 21/32 in-band to broad-band ratio */
8941 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8942 },
8943 { /* f300_425[] 16 */
8944 30741, /* A1 = 1.876282 */
8945 -31475, /* A2 = -0.960541 */
8946 -703, /* B2 = -0.021484 */
8947 0, /* B1 = 0 */
8948 703, /* B0 = 0.021484 */
8949 30688, /* A1 = 1.873047 */
8950 -32248, /* A2 = -0.984161 */
8951 14542, /* B2 = 0.443787 */
8952 -13523, /* B1 = -0.825439 */
8953 14542, /* B0 = 0.443817 */
8954 31494, /* A1 = 1.922302 */
8955 -32366, /* A2 = -0.987762 */
8956 21577, /* B2 = 0.658508 */
8957 -21013, /* B1 = -1.282532 */
8958 21577, /* B0 = 0.658508 */
8959 7, /* Internal filter scaling */
8960 159, /* Minimum in-band energy threshold */
8961 21, /* 21/32 in-band to broad-band ratio */
8962 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8963 },
8964 { /* f330_440[] 17 */
8965 30627, /* A1 = 1.869324 */
8966 -31338, /* A2 = -0.95636 */
8967 -843, /* B2 = -0.025749 */
8968 0, /* B1 = 0 */
8969 843, /* B0 = 0.025749 */
8970 30550, /* A1 = 1.864685 */
8971 -32221, /* A2 = -0.983337 */
8972 13594, /* B2 = 0.414886 */
8973 -12589, /* B1 = -0.768402 */
8974 13594, /* B0 = 0.414886 */
8975 31488, /* A1 = 1.921936 */
8976 -32358, /* A2 = -0.987518 */
8977 24684, /* B2 = 0.753296 */
8978 -24029, /* B1 = -1.466614 */
8979 24684, /* B0 = 0.753296 */
8980 7, /* Internal filter scaling */
8981 159, /* Minimum in-band energy threshold */
8982 21, /* 21/32 in-band to broad-band ratio */
8983 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8984 },
8985 { /* f340 18 */
8986 31546, /* A1 = -1.925476 */
8987 -32646, /* A2 = 0.996277 */
8988 -445, /* B2 = -0.013588 */
8989 0, /* B1 = 0.000000 */
8990 445, /* B0 = 0.013588 */
8991 31551, /* A1 = -1.925781 */
8992 -32713, /* A2 = 0.998352 */
8993 23884, /* B2 = 0.728882 */
8994 -22979, /* B1 = -1.402527 */
8995 23884, /* B0 = 0.728882 */
8996 31606, /* A1 = -1.929138 */
8997 -32715, /* A2 = 0.998413 */
8998 863, /* B2 = 0.026367 */
8999 -835, /* B1 = -0.050985 */
9000 863, /* B0 = 0.026367 */
9001 5, /* Internal filter scaling */
9002 159, /* Minimum in-band energy threshold */
9003 21, /* 21/32 in-band to broad-band ratio */
9004 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9005 },
9006 { /* f350_400[] 19 */
9007 31006, /* A1 = 1.892517 */
9008 -32029, /* A2 = -0.977448 */
9009 -461, /* B2 = -0.014096 */
9010 0, /* B1 = 0 */
9011 461, /* B0 = 0.014096 */
9012 30999, /* A1 = 1.892029 */
9013 -32487, /* A2 = -0.991455 */
9014 11325, /* B2 = 0.345612 */
9015 -10682, /* B1 = -0.651978 */
9016 11325, /* B0 = 0.345612 */
9017 31441, /* A1 = 1.919067 */
9018 -32526, /* A2 = -0.992615 */
9019 24324, /* B2 = 0.74231 */
9020 -23535, /* B1 = -1.436523 */
9021 24324, /* B0 = 0.74231 */
9022 7, /* Internal filter scaling */
9023 159, /* Minimum in-band energy threshold */
9024 21, /* 21/32 in-band to broad-band ratio */
9025 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9026 },
9027 { /* f350_440[] */
9028 30634, /* A1 = 1.869751 */
9029 -31533, /* A2 = -0.962341 */
9030 -680, /* B2 = -0.020782 */
9031 0, /* B1 = 0 */
9032 680, /* B0 = 0.020782 */
9033 30571, /* A1 = 1.865906 */
9034 -32277, /* A2 = -0.985016 */
9035 12894, /* B2 = 0.393524 */
9036 -11945, /* B1 = -0.729065 */
9037 12894, /* B0 = 0.393524 */
9038 31367, /* A1 = 1.91449 */
9039 -32379, /* A2 = -0.988129 */
9040 23820, /* B2 = 0.726929 */
9041 -23104, /* B1 = -1.410217 */
9042 23820, /* B0 = 0.726929 */
9043 7, /* Internal filter scaling */
9044 159, /* Minimum in-band energy threshold */
9045 21, /* 21/32 in-band to broad-band ratio */
9046 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9047 },
9048 { /* f350_450[] */
9049 30552, /* A1 = 1.864807 */
9050 -31434, /* A2 = -0.95929 */
9051 -690, /* B2 = -0.021066 */
9052 0, /* B1 = 0 */
9053 690, /* B0 = 0.021066 */
9054 30472, /* A1 = 1.859924 */
9055 -32248, /* A2 = -0.984161 */
9056 13385, /* B2 = 0.408478 */
9057 -12357, /* B1 = -0.754242 */
9058 13385, /* B0 = 0.408478 */
9059 31358, /* A1 = 1.914001 */
9060 -32366, /* A2 = -0.987732 */
9061 26488, /* B2 = 0.80835 */
9062 -25692, /* B1 = -1.568176 */
9063 26490, /* B0 = 0.808411 */
9064 7, /* Internal filter scaling */
9065 159, /* Minimum in-band energy threshold */
9066 21, /* 21/32 in-band to broad-band ratio */
9067 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9068 },
9069 { /* f360 */
9070 31397, /* A1 = -1.916321 */
9071 -32623, /* A2 = 0.995605 */
9072 -117, /* B2 = -0.003598 */
9073 0, /* B1 = 0.000000 */
9074 117, /* B0 = 0.003598 */
9075 31403, /* A1 = -1.916687 */
9076 -32700, /* A2 = 0.997925 */
9077 3388, /* B2 = 0.103401 */
9078 -3240, /* B1 = -0.197784 */
9079 3388, /* B0 = 0.103401 */
9080 31463, /* A1 = -1.920410 */
9081 -32702, /* A2 = 0.997986 */
9082 13346, /* B2 = 0.407288 */
9083 -12863, /* B1 = -0.785126 */
9084 13346, /* B0 = 0.407288 */
9085 5, /* Internal filter scaling */
9086 159, /* Minimum in-band energy threshold */
9087 21, /* 21/32 in-band to broad-band ratio */
9088 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9089 },
9090 { /* f380_420[] */
9091 30831, /* A1 = 1.881775 */
9092 -32064, /* A2 = -0.978546 */
9093 -367, /* B2 = -0.01122 */
9094 0, /* B1 = 0 */
9095 367, /* B0 = 0.01122 */
9096 30813, /* A1 = 1.880737 */
9097 -32456, /* A2 = -0.990509 */
9098 11068, /* B2 = 0.337769 */
9099 -10338, /* B1 = -0.631042 */
9100 11068, /* B0 = 0.337769 */
9101 31214, /* A1 = 1.905212 */
9102 -32491, /* A2 = -0.991577 */
9103 16374, /* B2 = 0.499695 */
9104 -15781, /* B1 = -0.963196 */
9105 16374, /* B0 = 0.499695 */
9106 7, /* Internal filter scaling */
9107 159, /* Minimum in-band energy threshold */
9108 21, /* 21/32 in-band to broad-band ratio */
9109 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9110 },
9111 { /* f392 */
9112 31152, /* A1 = -1.901428 */
9113 -32613, /* A2 = 0.995300 */
9114 -314, /* B2 = -0.009605 */
9115 0, /* B1 = 0.000000 */
9116 314, /* B0 = 0.009605 */
9117 31156, /* A1 = -1.901672 */
9118 -32694, /* A2 = 0.997742 */
9119 28847, /* B2 = 0.880371 */
9120 -2734, /* B1 = -0.166901 */
9121 28847, /* B0 = 0.880371 */
9122 31225, /* A1 = -1.905823 */
9123 -32696, /* A2 = 0.997803 */
9124 462, /* B2 = 0.014108 */
9125 -442, /* B1 = -0.027019 */
9126 462, /* B0 = 0.014108 */
9127 5, /* Internal filter scaling */
9128 159, /* Minimum in-band energy threshold */
9129 21, /* 21/32 in-band to broad-band ratio */
9130 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9131 },
9132 { /* f400_425[] */
9133 30836, /* A1 = 1.882141 */
9134 -32296, /* A2 = -0.985596 */
9135 -324, /* B2 = -0.009903 */
9136 0, /* B1 = 0 */
9137 324, /* B0 = 0.009903 */
9138 30825, /* A1 = 1.881409 */
9139 -32570, /* A2 = -0.993958 */
9140 16847, /* B2 = 0.51416 */
9141 -15792, /* B1 = -0.963898 */
9142 16847, /* B0 = 0.51416 */
9143 31106, /* A1 = 1.89856 */
9144 -32584, /* A2 = -0.994415 */
9145 9579, /* B2 = 0.292328 */
9146 -9164, /* B1 = -0.559357 */
9147 9579, /* B0 = 0.292328 */
9148 7, /* Internal filter scaling */
9149 159, /* Minimum in-band energy threshold */
9150 21, /* 21/32 in-band to broad-band ratio */
9151 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9152 },
9153 { /* f400_440[] */
9154 30702, /* A1 = 1.873962 */
9155 -32134, /* A2 = -0.980682 */
9156 -517, /* B2 = -0.015793 */
9157 0, /* B1 = 0 */
9158 517, /* B0 = 0.015793 */
9159 30676, /* A1 = 1.872375 */
9160 -32520, /* A2 = -0.992462 */
9161 8144, /* B2 = 0.24855 */
9162 -7596, /* B1 = -0.463684 */
9163 8144, /* B0 = 0.24855 */
9164 31084, /* A1 = 1.897217 */
9165 -32547, /* A2 = -0.993256 */
9166 22713, /* B2 = 0.693176 */
9167 -21734, /* B1 = -1.326599 */
9168 22713, /* B0 = 0.693176 */
9169 7, /* Internal filter scaling */
9170 159, /* Minimum in-band energy threshold */
9171 21, /* 21/32 in-band to broad-band ratio */
9172 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9173 },
9174 { /* f400_450[] */
9175 30613, /* A1 = 1.86853 */
9176 -32031, /* A2 = -0.977509 */
9177 -618, /* B2 = -0.018866 */
9178 0, /* B1 = 0 */
9179 618, /* B0 = 0.018866 */
9180 30577, /* A1 = 1.866272 */
9181 -32491, /* A2 = -0.991577 */
9182 9612, /* B2 = 0.293335 */
9183 -8935, /* B1 = -0.54541 */
9184 9612, /* B0 = 0.293335 */
9185 31071, /* A1 = 1.896484 */
9186 -32524, /* A2 = -0.992584 */
9187 21596, /* B2 = 0.659058 */
9188 -20667, /* B1 = -1.261414 */
9189 21596, /* B0 = 0.659058 */
9190 7, /* Internal filter scaling */
9191 159, /* Minimum in-band energy threshold */
9192 21, /* 21/32 in-band to broad-band ratio */
9193 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9194 },
9195 { /* f420 */
9196 30914, /* A1 = -1.886841 */
9197 -32584, /* A2 = 0.994385 */
9198 -426, /* B2 = -0.013020 */
9199 0, /* B1 = 0.000000 */
9200 426, /* B0 = 0.013020 */
9201 30914, /* A1 = -1.886841 */
9202 -32679, /* A2 = 0.997314 */
9203 17520, /* B2 = 0.534668 */
9204 -16471, /* B1 = -1.005310 */
9205 17520, /* B0 = 0.534668 */
9206 31004, /* A1 = -1.892334 */
9207 -32683, /* A2 = 0.997406 */
9208 819, /* B2 = 0.025023 */
9209 -780, /* B1 = -0.047619 */
9210 819, /* B0 = 0.025023 */
9211 5, /* Internal filter scaling */
9212 159, /* Minimum in-band energy threshold */
9213 21, /* 21/32 in-band to broad-band ratio */
9214 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9215 },
9216 #if 0
9217 { /* f425 */
9218 30881, /* A1 = -1.884827 */
9219 -32603, /* A2 = 0.994965 */
9220 -496, /* B2 = -0.015144 */
9221 0, /* B1 = 0.000000 */
9222 496, /* B0 = 0.015144 */
9223 30880, /* A1 = -1.884766 */
9224 -32692, /* A2 = 0.997711 */
9225 24767, /* B2 = 0.755859 */
9226 -23290, /* B1 = -1.421509 */
9227 24767, /* B0 = 0.755859 */
9228 30967, /* A1 = -1.890076 */
9229 -32694, /* A2 = 0.997772 */
9230 728, /* B2 = 0.022232 */
9231 -691, /* B1 = -0.042194 */
9232 728, /* B0 = 0.022232 */
9233 5, /* Internal filter scaling */
9234 159, /* Minimum in-band energy threshold */
9235 21, /* 21/32 in-band to broad-band ratio */
9236 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9237 },
9238 #else
9239 {
9240 30850,
9241 -32534,
9242 -504,
9243 0,
9244 504,
9245 30831,
9246 -32669,
9247 24303,
9248 -22080,
9249 24303,
9250 30994,
9251 -32673,
9252 1905,
9253 -1811,
9254 1905,
9255 5,
9256 129,
9257 17,
9258 0xff5
9259 },
9260 #endif
9261 { /* f425_450[] */
9262 30646, /* A1 = 1.870544 */
9263 -32327, /* A2 = -0.986572 */
9264 -287, /* B2 = -0.008769 */
9265 0, /* B1 = 0 */
9266 287, /* B0 = 0.008769 */
9267 30627, /* A1 = 1.869324 */
9268 -32607, /* A2 = -0.995087 */
9269 13269, /* B2 = 0.404968 */
9270 -12376, /* B1 = -0.755432 */
9271 13269, /* B0 = 0.404968 */
9272 30924, /* A1 = 1.887512 */
9273 -32619, /* A2 = -0.995453 */
9274 19950, /* B2 = 0.608826 */
9275 -18940, /* B1 = -1.156006 */
9276 19950, /* B0 = 0.608826 */
9277 7, /* Internal filter scaling */
9278 159, /* Minimum in-band energy threshold */
9279 21, /* 21/32 in-band to broad-band ratio */
9280 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9281 },
9282 { /* f425_475[] */
9283 30396, /* A1 = 1.855225 */
9284 -32014, /* A2 = -0.97699 */
9285 -395, /* B2 = -0.012055 */
9286 0, /* B1 = 0 */
9287 395, /* B0 = 0.012055 */
9288 30343, /* A1 = 1.85199 */
9289 -32482, /* A2 = -0.991302 */
9290 17823, /* B2 = 0.543945 */
9291 -16431, /* B1 = -1.002869 */
9292 17823, /* B0 = 0.543945 */
9293 30872, /* A1 = 1.884338 */
9294 -32516, /* A2 = -0.99231 */
9295 18124, /* B2 = 0.553101 */
9296 -17246, /* B1 = -1.052673 */
9297 18124, /* B0 = 0.553101 */
9298 7, /* Internal filter scaling */
9299 159, /* Minimum in-band energy threshold */
9300 21, /* 21/32 in-band to broad-band ratio */
9301 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9302 },
9303 { /* f435 */
9304 30796, /* A1 = -1.879639 */
9305 -32603, /* A2 = 0.994965 */
9306 -254, /* B2 = -0.007762 */
9307 0, /* B1 = 0.000000 */
9308 254, /* B0 = 0.007762 */
9309 30793, /* A1 = -1.879456 */
9310 -32692, /* A2 = 0.997711 */
9311 18934, /* B2 = 0.577820 */
9312 -17751, /* B1 = -1.083496 */
9313 18934, /* B0 = 0.577820 */
9314 30882, /* A1 = -1.884888 */
9315 -32694, /* A2 = 0.997772 */
9316 1858, /* B2 = 0.056713 */
9317 -1758, /* B1 = -0.107357 */
9318 1858, /* B0 = 0.056713 */
9319 5, /* Internal filter scaling */
9320 159, /* Minimum in-band energy threshold */
9321 21, /* 21/32 in-band to broad-band ratio */
9322 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9323 },
9324 { /* f440_450[] */
9325 30641, /* A1 = 1.870239 */
9326 -32458, /* A2 = -0.99057 */
9327 -155, /* B2 = -0.004735 */
9328 0, /* B1 = 0 */
9329 155, /* B0 = 0.004735 */
9330 30631, /* A1 = 1.869568 */
9331 -32630, /* A2 = -0.995789 */
9332 11453, /* B2 = 0.349548 */
9333 -10666, /* B1 = -0.651001 */
9334 11453, /* B0 = 0.349548 */
9335 30810, /* A1 = 1.880554 */
9336 -32634, /* A2 = -0.995941 */
9337 12237, /* B2 = 0.373474 */
9338 -11588, /* B1 = -0.707336 */
9339 12237, /* B0 = 0.373474 */
9340 7, /* Internal filter scaling */
9341 159, /* Minimum in-band energy threshold */
9342 21, /* 21/32 in-band to broad-band ratio */
9343 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9344 },
9345 { /* f440_480[] */
9346 30367, /* A1 = 1.853455 */
9347 -32147, /* A2 = -0.981079 */
9348 -495, /* B2 = -0.015113 */
9349 0, /* B1 = 0 */
9350 495, /* B0 = 0.015113 */
9351 30322, /* A1 = 1.850769 */
9352 -32543, /* A2 = -0.993134 */
9353 10031, /* B2 = 0.306152 */
9354 -9252, /* B1 = -0.564728 */
9355 10031, /* B0 = 0.306152 */
9356 30770, /* A1 = 1.878052 */
9357 -32563, /* A2 = -0.993774 */
9358 22674, /* B2 = 0.691956 */
9359 -21465, /* B1 = -1.31012 */
9360 22674, /* B0 = 0.691956 */
9361 7, /* Internal filter scaling */
9362 159, /* Minimum in-band energy threshold */
9363 21, /* 21/32 in-band to broad-band ratio */
9364 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9365 },
9366 { /* f445 */
9367 30709, /* A1 = -1.874329 */
9368 -32603, /* A2 = 0.994965 */
9369 -83, /* B2 = -0.002545 */
9370 0, /* B1 = 0.000000 */
9371 83, /* B0 = 0.002545 */
9372 30704, /* A1 = -1.874084 */
9373 -32692, /* A2 = 0.997711 */
9374 10641, /* B2 = 0.324738 */
9375 -9947, /* B1 = -0.607147 */
9376 10641, /* B0 = 0.324738 */
9377 30796, /* A1 = -1.879639 */
9378 -32694, /* A2 = 0.997772 */
9379 10079, /* B2 = 0.307587 */
9380 9513, /* B1 = 0.580688 */
9381 10079, /* B0 = 0.307587 */
9382 5, /* Internal filter scaling */
9383 159, /* Minimum in-band energy threshold */
9384 21, /* 21/32 in-band to broad-band ratio */
9385 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9386 },
9387 { /* f450 */
9388 30664, /* A1 = -1.871643 */
9389 -32603, /* A2 = 0.994965 */
9390 -164, /* B2 = -0.005029 */
9391 0, /* B1 = 0.000000 */
9392 164, /* B0 = 0.005029 */
9393 30661, /* A1 = -1.871399 */
9394 -32692, /* A2 = 0.997711 */
9395 15294, /* B2 = 0.466736 */
9396 -14275, /* B1 = -0.871307 */
9397 15294, /* B0 = 0.466736 */
9398 30751, /* A1 = -1.876953 */
9399 -32694, /* A2 = 0.997772 */
9400 3548, /* B2 = 0.108284 */
9401 -3344, /* B1 = -0.204155 */
9402 3548, /* B0 = 0.108284 */
9403 5, /* Internal filter scaling */
9404 159, /* Minimum in-band energy threshold */
9405 21, /* 21/32 in-band to broad-band ratio */
9406 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9407 },
9408 { /* f452 */
9409 30653, /* A1 = -1.870911 */
9410 -32615, /* A2 = 0.995361 */
9411 -209, /* B2 = -0.006382 */
9412 0, /* B1 = 0.000000 */
9413 209, /* B0 = 0.006382 */
9414 30647, /* A1 = -1.870605 */
9415 -32702, /* A2 = 0.997986 */
9416 18971, /* B2 = 0.578979 */
9417 -17716, /* B1 = -1.081299 */
9418 18971, /* B0 = 0.578979 */
9419 30738, /* A1 = -1.876099 */
9420 -32702, /* A2 = 0.998016 */
9421 2967, /* B2 = 0.090561 */
9422 -2793, /* B1 = -0.170502 */
9423 2967, /* B0 = 0.090561 */
9424 5, /* Internal filter scaling */
9425 159, /* Minimum in-band energy threshold */
9426 21, /* 21/32 in-band to broad-band ratio */
9427 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9428 },
9429 { /* f475 */
9430 30437, /* A1 = -1.857727 */
9431 -32603, /* A2 = 0.994965 */
9432 -264, /* B2 = -0.008062 */
9433 0, /* B1 = 0.000000 */
9434 264, /* B0 = 0.008062 */
9435 30430, /* A1 = -1.857300 */
9436 -32692, /* A2 = 0.997711 */
9437 21681, /* B2 = 0.661682 */
9438 -20082, /* B1 = -1.225708 */
9439 21681, /* B0 = 0.661682 */
9440 30526, /* A1 = -1.863220 */
9441 -32694, /* A2 = 0.997742 */
9442 1559, /* B2 = 0.047600 */
9443 -1459, /* B1 = -0.089096 */
9444 1559, /* B0 = 0.047600 */
9445 5, /* Internal filter scaling */
9446 159, /* Minimum in-band energy threshold */
9447 21, /* 21/32 in-band to broad-band ratio */
9448 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9449 },
9450 { /* f480_620[] */
9451 28975, /* A1 = 1.768494 */
9452 -30955, /* A2 = -0.944672 */
9453 -1026, /* B2 = -0.03133 */
9454 0, /* B1 = 0 */
9455 1026, /* B0 = 0.03133 */
9456 28613, /* A1 = 1.746399 */
9457 -32089, /* A2 = -0.979309 */
9458 14214, /* B2 = 0.433807 */
9459 -12202, /* B1 = -0.744812 */
9460 14214, /* B0 = 0.433807 */
9461 30243, /* A1 = 1.845947 */
9462 -32238, /* A2 = -0.983856 */
9463 24825, /* B2 = 0.757629 */
9464 -23402, /* B1 = -1.428345 */
9465 24825, /* B0 = 0.757629 */
9466 7, /* Internal filter scaling */
9467 159, /* Minimum in-band energy threshold */
9468 21, /* 21/32 in-band to broad-band ratio */
9469 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9470 },
9471 { /* f494 */
9472 30257, /* A1 = -1.846741 */
9473 -32605, /* A2 = 0.995056 */
9474 -249, /* B2 = -0.007625 */
9475 0, /* B1 = 0.000000 */
9476 249, /* B0 = 0.007625 */
9477 30247, /* A1 = -1.846191 */
9478 -32694, /* A2 = 0.997772 */
9479 18088, /* B2 = 0.552002 */
9480 -16652, /* B1 = -1.016418 */
9481 18088, /* B0 = 0.552002 */
9482 30348, /* A1 = -1.852295 */
9483 -32696, /* A2 = 0.997803 */
9484 2099, /* B2 = 0.064064 */
9485 -1953, /* B1 = -0.119202 */
9486 2099, /* B0 = 0.064064 */
9487 5, /* Internal filter scaling */
9488 159, /* Minimum in-band energy threshold */
9489 21, /* 21/32 in-band to broad-band ratio */
9490 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9491 },
9492 { /* f500 */
9493 30202, /* A1 = -1.843431 */
9494 -32624, /* A2 = 0.995622 */
9495 -413, /* B2 = -0.012622 */
9496 0, /* B1 = 0.000000 */
9497 413, /* B0 = 0.012622 */
9498 30191, /* A1 = -1.842721 */
9499 -32714, /* A2 = 0.998364 */
9500 25954, /* B2 = 0.792057 */
9501 -23890, /* B1 = -1.458131 */
9502 25954, /* B0 = 0.792057 */
9503 30296, /* A1 = -1.849172 */
9504 -32715, /* A2 = 0.998397 */
9505 2007, /* B2 = 0.061264 */
9506 -1860, /* B1 = -0.113568 */
9507 2007, /* B0 = 0.061264 */
9508 5, /* Internal filter scaling */
9509 159, /* Minimum in-band energy threshold */
9510 21, /* 21/32 in-band to broad-band ratio */
9511 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9512 },
9513 { /* f520 */
9514 30001, /* A1 = -1.831116 */
9515 -32613, /* A2 = 0.995270 */
9516 -155, /* B2 = -0.004750 */
9517 0, /* B1 = 0.000000 */
9518 155, /* B0 = 0.004750 */
9519 29985, /* A1 = -1.830200 */
9520 -32710, /* A2 = 0.998260 */
9521 6584, /* B2 = 0.200928 */
9522 -6018, /* B1 = -0.367355 */
9523 6584, /* B0 = 0.200928 */
9524 30105, /* A1 = -1.837524 */
9525 -32712, /* A2 = 0.998291 */
9526 23812, /* B2 = 0.726685 */
9527 -21936, /* B1 = -1.338928 */
9528 23812, /* B0 = 0.726685 */
9529 5, /* Internal filter scaling */
9530 159, /* Minimum in-band energy threshold */
9531 21, /* 21/32 in-band to broad-band ratio */
9532 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9533 },
9534 { /* f523 */
9535 29964, /* A1 = -1.828918 */
9536 -32601, /* A2 = 0.994904 */
9537 -101, /* B2 = -0.003110 */
9538 0, /* B1 = 0.000000 */
9539 101, /* B0 = 0.003110 */
9540 29949, /* A1 = -1.827942 */
9541 -32700, /* A2 = 0.997925 */
9542 11041, /* B2 = 0.336975 */
9543 -10075, /* B1 = -0.614960 */
9544 11041, /* B0 = 0.336975 */
9545 30070, /* A1 = -1.835388 */
9546 -32702, /* A2 = 0.997986 */
9547 16762, /* B2 = 0.511536 */
9548 -15437, /* B1 = -0.942230 */
9549 16762, /* B0 = 0.511536 */
9550 5, /* Internal filter scaling */
9551 159, /* Minimum in-band energy threshold */
9552 21, /* 21/32 in-band to broad-band ratio */
9553 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9554 },
9555 { /* f525 */
9556 29936, /* A1 = -1.827209 */
9557 -32584, /* A2 = 0.994415 */
9558 -91, /* B2 = -0.002806 */
9559 0, /* B1 = 0.000000 */
9560 91, /* B0 = 0.002806 */
9561 29921, /* A1 = -1.826233 */
9562 -32688, /* A2 = 0.997559 */
9563 11449, /* B2 = 0.349396 */
9564 -10426, /* B1 = -0.636383 */
9565 11449, /* B0 = 0.349396 */
9566 30045, /* A1 = -1.833862 */
9567 -32688, /* A2 = 0.997589 */
9568 13055, /* B2 = 0.398407 */
9569 -12028, /* B1 = -0.734161 */
9570 13055, /* B0 = 0.398407 */
9571 5, /* Internal filter scaling */
9572 159, /* Minimum in-band energy threshold */
9573 21, /* 21/32 in-band to broad-band ratio */
9574 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9575 },
9576 { /* f540_660[] */
9577 28499, /* A1 = 1.739441 */
9578 -31129, /* A2 = -0.949982 */
9579 -849, /* B2 = -0.025922 */
9580 0, /* B1 = 0 */
9581 849, /* B0 = 0.025922 */
9582 28128, /* A1 = 1.716797 */
9583 -32130, /* A2 = -0.98056 */
9584 14556, /* B2 = 0.444214 */
9585 -12251, /* B1 = -0.747772 */
9586 14556, /* B0 = 0.444244 */
9587 29667, /* A1 = 1.81073 */
9588 -32244, /* A2 = -0.984039 */
9589 23038, /* B2 = 0.703064 */
9590 -21358, /* B1 = -1.303589 */
9591 23040, /* B0 = 0.703125 */
9592 7, /* Internal filter scaling */
9593 159, /* Minimum in-band energy threshold */
9594 21, /* 21/32 in-band to broad-band ratio */
9595 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9596 },
9597 { /* f587 */
9598 29271, /* A1 = -1.786560 */
9599 -32599, /* A2 = 0.994873 */
9600 -490, /* B2 = -0.014957 */
9601 0, /* B1 = 0.000000 */
9602 490, /* B0 = 0.014957 */
9603 29246, /* A1 = -1.785095 */
9604 -32700, /* A2 = 0.997925 */
9605 28961, /* B2 = 0.883850 */
9606 -25796, /* B1 = -1.574463 */
9607 28961, /* B0 = 0.883850 */
9608 29383, /* A1 = -1.793396 */
9609 -32700, /* A2 = 0.997955 */
9610 1299, /* B2 = 0.039650 */
9611 -1169, /* B1 = -0.071396 */
9612 1299, /* B0 = 0.039650 */
9613 5, /* Internal filter scaling */
9614 159, /* Minimum in-band energy threshold */
9615 21, /* 21/32 in-band to broad-band ratio */
9616 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9617 },
9618 { /* f590 */
9619 29230, /* A1 = -1.784058 */
9620 -32584, /* A2 = 0.994415 */
9621 -418, /* B2 = -0.012757 */
9622 0, /* B1 = 0.000000 */
9623 418, /* B0 = 0.012757 */
9624 29206, /* A1 = -1.782593 */
9625 -32688, /* A2 = 0.997559 */
9626 36556, /* B2 = 1.115601 */
9627 -32478, /* B1 = -1.982300 */
9628 36556, /* B0 = 1.115601 */
9629 29345, /* A1 = -1.791077 */
9630 -32688, /* A2 = 0.997589 */
9631 897, /* B2 = 0.027397 */
9632 -808, /* B1 = -0.049334 */
9633 897, /* B0 = 0.027397 */
9634 5, /* Internal filter scaling */
9635 159, /* Minimum in-band energy threshold */
9636 21, /* 21/32 in-band to broad-band ratio */
9637 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9638 },
9639 { /* f600 */
9640 29116, /* A1 = -1.777100 */
9641 -32603, /* A2 = 0.994965 */
9642 -165, /* B2 = -0.005039 */
9643 0, /* B1 = 0.000000 */
9644 165, /* B0 = 0.005039 */
9645 29089, /* A1 = -1.775452 */
9646 -32708, /* A2 = 0.998199 */
9647 6963, /* B2 = 0.212494 */
9648 -6172, /* B1 = -0.376770 */
9649 6963, /* B0 = 0.212494 */
9650 29237, /* A1 = -1.784485 */
9651 -32710, /* A2 = 0.998230 */
9652 24197, /* B2 = 0.738464 */
9653 -21657, /* B1 = -1.321899 */
9654 24197, /* B0 = 0.738464 */
9655 5, /* Internal filter scaling */
9656 159, /* Minimum in-band energy threshold */
9657 21, /* 21/32 in-band to broad-band ratio */
9658 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9659 },
9660 { /* f660 */
9661 28376, /* A1 = -1.731934 */
9662 -32567, /* A2 = 0.993896 */
9663 -363, /* B2 = -0.011102 */
9664 0, /* B1 = 0.000000 */
9665 363, /* B0 = 0.011102 */
9666 28337, /* A1 = -1.729614 */
9667 -32683, /* A2 = 0.997434 */
9668 21766, /* B2 = 0.664246 */
9669 -18761, /* B1 = -1.145081 */
9670 21766, /* B0 = 0.664246 */
9671 28513, /* A1 = -1.740356 */
9672 -32686, /* A2 = 0.997498 */
9673 2509, /* B2 = 0.076584 */
9674 -2196, /* B1 = -0.134041 */
9675 2509, /* B0 = 0.076584 */
9676 5, /* Internal filter scaling */
9677 159, /* Minimum in-band energy threshold */
9678 21, /* 21/32 in-band to broad-band ratio */
9679 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9680 },
9681 { /* f700 */
9682 27844, /* A1 = -1.699463 */
9683 -32563, /* A2 = 0.993744 */
9684 -366, /* B2 = -0.011187 */
9685 0, /* B1 = 0.000000 */
9686 366, /* B0 = 0.011187 */
9687 27797, /* A1 = -1.696655 */
9688 -32686, /* A2 = 0.997498 */
9689 22748, /* B2 = 0.694214 */
9690 -19235, /* B1 = -1.174072 */
9691 22748, /* B0 = 0.694214 */
9692 27995, /* A1 = -1.708740 */
9693 -32688, /* A2 = 0.997559 */
9694 2964, /* B2 = 0.090477 */
9695 -2546, /* B1 = -0.155449 */
9696 2964, /* B0 = 0.090477 */
9697 5, /* Internal filter scaling */
9698 159, /* Minimum in-band energy threshold */
9699 21, /* 21/32 in-band to broad-band ratio */
9700 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9701 },
9702 { /* f740 */
9703 27297, /* A1 = -1.666077 */
9704 -32551, /* A2 = 0.993408 */
9705 -345, /* B2 = -0.010540 */
9706 0, /* B1 = 0.000000 */
9707 345, /* B0 = 0.010540 */
9708 27240, /* A1 = -1.662598 */
9709 -32683, /* A2 = 0.997406 */
9710 22560, /* B2 = 0.688477 */
9711 -18688, /* B1 = -1.140625 */
9712 22560, /* B0 = 0.688477 */
9713 27461, /* A1 = -1.676147 */
9714 -32684, /* A2 = 0.997467 */
9715 3541, /* B2 = 0.108086 */
9716 -2985, /* B1 = -0.182220 */
9717 3541, /* B0 = 0.108086 */
9718 5, /* Internal filter scaling */
9719 159, /* Minimum in-band energy threshold */
9720 21, /* 21/32 in-band to broad-band ratio */
9721 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9722 },
9723 { /* f750 */
9724 27155, /* A1 = -1.657410 */
9725 -32551, /* A2 = 0.993408 */
9726 -462, /* B2 = -0.014117 */
9727 0, /* B1 = 0.000000 */
9728 462, /* B0 = 0.014117 */
9729 27097, /* A1 = -1.653870 */
9730 -32683, /* A2 = 0.997406 */
9731 32495, /* B2 = 0.991699 */
9732 -26776, /* B1 = -1.634338 */
9733 32495, /* B0 = 0.991699 */
9734 27321, /* A1 = -1.667542 */
9735 -32684, /* A2 = 0.997467 */
9736 1835, /* B2 = 0.056007 */
9737 -1539, /* B1 = -0.093948 */
9738 1835, /* B0 = 0.056007 */
9739 5, /* Internal filter scaling */
9740 159, /* Minimum in-band energy threshold */
9741 21, /* 21/32 in-band to broad-band ratio */
9742 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9743 },
9744 { /* f750_1450[] */
9745 19298, /* A1 = 1.177917 */
9746 -24471, /* A2 = -0.746796 */
9747 -4152, /* B2 = -0.126709 */
9748 0, /* B1 = 0 */
9749 4152, /* B0 = 0.126709 */
9750 12902, /* A1 = 0.787476 */
9751 -29091, /* A2 = -0.887817 */
9752 12491, /* B2 = 0.38121 */
9753 -1794, /* B1 = -0.109528 */
9754 12494, /* B0 = 0.381317 */
9755 26291, /* A1 = 1.604736 */
9756 -30470, /* A2 = -0.929901 */
9757 28859, /* B2 = 0.880737 */
9758 -26084, /* B1 = -1.592102 */
9759 28861, /* B0 = 0.880798 */
9760 7, /* Internal filter scaling */
9761 159, /* Minimum in-band energy threshold */
9762 21, /* 21/32 in-band to broad-band ratio */
9763 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9764 },
9765 { /* f770 */
9766 26867, /* A1 = -1.639832 */
9767 -32551, /* A2 = 0.993408 */
9768 -123, /* B2 = -0.003755 */
9769 0, /* B1 = 0.000000 */
9770 123, /* B0 = 0.003755 */
9771 26805, /* A1 = -1.636108 */
9772 -32683, /* A2 = 0.997406 */
9773 17297, /* B2 = 0.527863 */
9774 -14096, /* B1 = -0.860382 */
9775 17297, /* B0 = 0.527863 */
9776 27034, /* A1 = -1.650085 */
9777 -32684, /* A2 = 0.997467 */
9778 12958, /* B2 = 0.395477 */
9779 -10756, /* B1 = -0.656525 */
9780 12958, /* B0 = 0.395477 */
9781 5, /* Internal filter scaling */
9782 159, /* Minimum in-band energy threshold */
9783 21, /* 21/32 in-band to broad-band ratio */
9784 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9785 },
9786 { /* f800 */
9787 26413, /* A1 = -1.612122 */
9788 -32547, /* A2 = 0.993286 */
9789 -223, /* B2 = -0.006825 */
9790 0, /* B1 = 0.000000 */
9791 223, /* B0 = 0.006825 */
9792 26342, /* A1 = -1.607849 */
9793 -32686, /* A2 = 0.997498 */
9794 6391, /* B2 = 0.195053 */
9795 -5120, /* B1 = -0.312531 */
9796 6391, /* B0 = 0.195053 */
9797 26593, /* A1 = -1.623108 */
9798 -32688, /* A2 = 0.997559 */
9799 23681, /* B2 = 0.722717 */
9800 -19328, /* B1 = -1.179688 */
9801 23681, /* B0 = 0.722717 */
9802 5, /* Internal filter scaling */
9803 159, /* Minimum in-band energy threshold */
9804 21, /* 21/32 in-band to broad-band ratio */
9805 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9806 },
9807 { /* f816 */
9808 26168, /* A1 = -1.597209 */
9809 -32528, /* A2 = 0.992706 */
9810 -235, /* B2 = -0.007182 */
9811 0, /* B1 = 0.000000 */
9812 235, /* B0 = 0.007182 */
9813 26092, /* A1 = -1.592590 */
9814 -32675, /* A2 = 0.997192 */
9815 20823, /* B2 = 0.635498 */
9816 -16510, /* B1 = -1.007751 */
9817 20823, /* B0 = 0.635498 */
9818 26363, /* A1 = -1.609070 */
9819 -32677, /* A2 = 0.997253 */
9820 6739, /* B2 = 0.205688 */
9821 -5459, /* B1 = -0.333206 */
9822 6739, /* B0 = 0.205688 */
9823 5, /* Internal filter scaling */
9824 159, /* Minimum in-band energy threshold */
9825 21, /* 21/32 in-band to broad-band ratio */
9826 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9827 },
9828 { /* f850 */
9829 25641, /* A1 = -1.565063 */
9830 -32536, /* A2 = 0.992950 */
9831 -121, /* B2 = -0.003707 */
9832 0, /* B1 = 0.000000 */
9833 121, /* B0 = 0.003707 */
9834 25560, /* A1 = -1.560059 */
9835 -32684, /* A2 = 0.997437 */
9836 18341, /* B2 = 0.559753 */
9837 -14252, /* B1 = -0.869904 */
9838 18341, /* B0 = 0.559753 */
9839 25837, /* A1 = -1.577026 */
9840 -32684, /* A2 = 0.997467 */
9841 16679, /* B2 = 0.509003 */
9842 -13232, /* B1 = -0.807648 */
9843 16679, /* B0 = 0.509003 */
9844 5, /* Internal filter scaling */
9845 159, /* Minimum in-band energy threshold */
9846 21, /* 21/32 in-band to broad-band ratio */
9847 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9848 },
9849 { /* f857_1645[] */
9850 16415, /* A1 = 1.001953 */
9851 -23669, /* A2 = -0.722321 */
9852 -4549, /* B2 = -0.138847 */
9853 0, /* B1 = 0 */
9854 4549, /* B0 = 0.138847 */
9855 8456, /* A1 = 0.516174 */
9856 -28996, /* A2 = -0.884918 */
9857 13753, /* B2 = 0.419724 */
9858 -12, /* B1 = -0.000763 */
9859 13757, /* B0 = 0.419846 */
9860 24632, /* A1 = 1.503418 */
9861 -30271, /* A2 = -0.923828 */
9862 29070, /* B2 = 0.887146 */
9863 -25265, /* B1 = -1.542114 */
9864 29073, /* B0 = 0.887268 */
9865 7, /* Internal filter scaling */
9866 159, /* Minimum in-band energy threshold */
9867 21, /* 21/32 in-band to broad-band ratio */
9868 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9869 },
9870 { /* f900 */
9871 24806, /* A1 = -1.514099 */
9872 -32501, /* A2 = 0.991852 */
9873 -326, /* B2 = -0.009969 */
9874 0, /* B1 = 0.000000 */
9875 326, /* B0 = 0.009969 */
9876 24709, /* A1 = -1.508118 */
9877 -32659, /* A2 = 0.996674 */
9878 20277, /* B2 = 0.618835 */
9879 -15182, /* B1 = -0.926636 */
9880 20277, /* B0 = 0.618835 */
9881 25022, /* A1 = -1.527222 */
9882 -32661, /* A2 = 0.996735 */
9883 4320, /* B2 = 0.131836 */
9884 -3331, /* B1 = -0.203339 */
9885 4320, /* B0 = 0.131836 */
9886 5, /* Internal filter scaling */
9887 159, /* Minimum in-band energy threshold */
9888 21, /* 21/32 in-band to broad-band ratio */
9889 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9890 },
9891 { /* f900_1300[] */
9892 19776, /* A1 = 1.207092 */
9893 -27437, /* A2 = -0.837341 */
9894 -2666, /* B2 = -0.081371 */
9895 0, /* B1 = 0 */
9896 2666, /* B0 = 0.081371 */
9897 16302, /* A1 = 0.995026 */
9898 -30354, /* A2 = -0.926361 */
9899 10389, /* B2 = 0.317062 */
9900 -3327, /* B1 = -0.203064 */
9901 10389, /* B0 = 0.317062 */
9902 24299, /* A1 = 1.483154 */
9903 -30930, /* A2 = -0.943909 */
9904 25016, /* B2 = 0.763428 */
9905 -21171, /* B1 = -1.292236 */
9906 25016, /* B0 = 0.763428 */
9907 7, /* Internal filter scaling */
9908 159, /* Minimum in-band energy threshold */
9909 21, /* 21/32 in-band to broad-band ratio */
9910 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9911 },
9912 { /* f935_1215[] */
9913 20554, /* A1 = 1.254517 */
9914 -28764, /* A2 = -0.877838 */
9915 -2048, /* B2 = -0.062515 */
9916 0, /* B1 = 0 */
9917 2048, /* B0 = 0.062515 */
9918 18209, /* A1 = 1.11145 */
9919 -30951, /* A2 = -0.94458 */
9920 9390, /* B2 = 0.286575 */
9921 -3955, /* B1 = -0.241455 */
9922 9390, /* B0 = 0.286575 */
9923 23902, /* A1 = 1.458923 */
9924 -31286, /* A2 = -0.954803 */
9925 23252, /* B2 = 0.709595 */
9926 -19132, /* B1 = -1.167725 */
9927 23252, /* B0 = 0.709595 */
9928 7, /* Internal filter scaling */
9929 159, /* Minimum in-band energy threshold */
9930 21, /* 21/32 in-band to broad-band ratio */
9931 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9932 },
9933 { /* f941_1477[] */
9934 17543, /* A1 = 1.07074 */
9935 -26220, /* A2 = -0.800201 */
9936 -3298, /* B2 = -0.100647 */
9937 0, /* B1 = 0 */
9938 3298, /* B0 = 0.100647 */
9939 12423, /* A1 = 0.75827 */
9940 -30036, /* A2 = -0.916626 */
9941 12651, /* B2 = 0.386078 */
9942 -2444, /* B1 = -0.14917 */
9943 12653, /* B0 = 0.386154 */
9944 23518, /* A1 = 1.435425 */
9945 -30745, /* A2 = -0.938293 */
9946 27282, /* B2 = 0.832581 */
9947 -22529, /* B1 = -1.375122 */
9948 27286, /* B0 = 0.832703 */
9949 7, /* Internal filter scaling */
9950 159, /* Minimum in-band energy threshold */
9951 21, /* 21/32 in-band to broad-band ratio */
9952 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9953 },
9954 { /* f942 */
9955 24104, /* A1 = -1.471252 */
9956 -32507, /* A2 = 0.992065 */
9957 -351, /* B2 = -0.010722 */
9958 0, /* B1 = 0.000000 */
9959 351, /* B0 = 0.010722 */
9960 23996, /* A1 = -1.464600 */
9961 -32671, /* A2 = 0.997040 */
9962 22848, /* B2 = 0.697266 */
9963 -16639, /* B1 = -1.015564 */
9964 22848, /* B0 = 0.697266 */
9965 24332, /* A1 = -1.485168 */
9966 -32673, /* A2 = 0.997101 */
9967 4906, /* B2 = 0.149727 */
9968 -3672, /* B1 = -0.224174 */
9969 4906, /* B0 = 0.149727 */
9970 5, /* Internal filter scaling */
9971 159, /* Minimum in-band energy threshold */
9972 21, /* 21/32 in-band to broad-band ratio */
9973 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9974 },
9975 { /* f950 */
9976 23967, /* A1 = -1.462830 */
9977 -32507, /* A2 = 0.992065 */
9978 -518, /* B2 = -0.015821 */
9979 0, /* B1 = 0.000000 */
9980 518, /* B0 = 0.015821 */
9981 23856, /* A1 = -1.456055 */
9982 -32671, /* A2 = 0.997040 */
9983 26287, /* B2 = 0.802246 */
9984 -19031, /* B1 = -1.161560 */
9985 26287, /* B0 = 0.802246 */
9986 24195, /* A1 = -1.476746 */
9987 -32673, /* A2 = 0.997101 */
9988 2890, /* B2 = 0.088196 */
9989 -2151, /* B1 = -0.131317 */
9990 2890, /* B0 = 0.088196 */
9991 5, /* Internal filter scaling */
9992 159, /* Minimum in-band energy threshold */
9993 21, /* 21/32 in-band to broad-band ratio */
9994 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9995 },
9996 { /* f950_1400[] */
9997 18294, /* A1 = 1.116638 */
9998 -26962, /* A2 = -0.822845 */
9999 -2914, /* B2 = -0.088936 */
10000 0, /* B1 = 0 */
10001 2914, /* B0 = 0.088936 */
10002 14119, /* A1 = 0.861786 */
10003 -30227, /* A2 = -0.922455 */
10004 11466, /* B2 = 0.349945 */
10005 -2833, /* B1 = -0.172943 */
10006 11466, /* B0 = 0.349945 */
10007 23431, /* A1 = 1.430115 */
10008 -30828, /* A2 = -0.940796 */
10009 25331, /* B2 = 0.773071 */
10010 -20911, /* B1 = -1.276367 */
10011 25331, /* B0 = 0.773071 */
10012 7, /* Internal filter scaling */
10013 159, /* Minimum in-band energy threshold */
10014 21, /* 21/32 in-band to broad-band ratio */
10015 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10016 },
10017 { /* f975 */
10018 23521, /* A1 = -1.435608 */
10019 -32489, /* A2 = 0.991516 */
10020 -193, /* B2 = -0.005915 */
10021 0, /* B1 = 0.000000 */
10022 193, /* B0 = 0.005915 */
10023 23404, /* A1 = -1.428467 */
10024 -32655, /* A2 = 0.996582 */
10025 17740, /* B2 = 0.541412 */
10026 -12567, /* B1 = -0.767029 */
10027 17740, /* B0 = 0.541412 */
10028 23753, /* A1 = -1.449829 */
10029 -32657, /* A2 = 0.996613 */
10030 9090, /* B2 = 0.277405 */
10031 -6662, /* B1 = -0.406647 */
10032 9090, /* B0 = 0.277405 */
10033 5, /* Internal filter scaling */
10034 159, /* Minimum in-band energy threshold */
10035 21, /* 21/32 in-band to broad-band ratio */
10036 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10037 },
10038 { /* f1000 */
10039 23071, /* A1 = -1.408203 */
10040 -32489, /* A2 = 0.991516 */
10041 -293, /* B2 = -0.008965 */
10042 0, /* B1 = 0.000000 */
10043 293, /* B0 = 0.008965 */
10044 22951, /* A1 = -1.400818 */
10045 -32655, /* A2 = 0.996582 */
10046 5689, /* B2 = 0.173645 */
10047 -3951, /* B1 = -0.241150 */
10048 5689, /* B0 = 0.173645 */
10049 23307, /* A1 = -1.422607 */
10050 -32657, /* A2 = 0.996613 */
10051 18692, /* B2 = 0.570435 */
10052 -13447, /* B1 = -0.820770 */
10053 18692, /* B0 = 0.570435 */
10054 5, /* Internal filter scaling */
10055 159, /* Minimum in-band energy threshold */
10056 21, /* 21/32 in-band to broad-band ratio */
10057 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10058 },
10059 { /* f1020 */
10060 22701, /* A1 = -1.385620 */
10061 -32474, /* A2 = 0.991058 */
10062 -292, /* B2 = -0.008933 */
10063 0, /*163840 , B1 = 10.000000 */
10064 292, /* B0 = 0.008933 */
10065 22564, /* A1 = -1.377258 */
10066 -32655, /* A2 = 0.996552 */
10067 20756, /* B2 = 0.633423 */
10068 -14176, /* B1 = -0.865295 */
10069 20756, /* B0 = 0.633423 */
10070 22960, /* A1 = -1.401428 */
10071 -32657, /* A2 = 0.996613 */
10072 6520, /* B2 = 0.198990 */
10073 -4619, /* B1 = -0.281937 */
10074 6520, /* B0 = 0.198990 */
10075 5, /* Internal filter scaling */
10076 159, /* Minimum in-band energy threshold */
10077 21, /* 21/32 in-band to broad-band ratio */
10078 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10079 },
10080 { /* f1050 */
10081 22142, /* A1 = -1.351501 */
10082 -32474, /* A2 = 0.991058 */
10083 -147, /* B2 = -0.004493 */
10084 0, /* B1 = 0.000000 */
10085 147, /* B0 = 0.004493 */
10086 22000, /* A1 = -1.342834 */
10087 -32655, /* A2 = 0.996552 */
10088 15379, /* B2 = 0.469360 */
10089 -10237, /* B1 = -0.624847 */
10090 15379, /* B0 = 0.469360 */
10091 22406, /* A1 = -1.367554 */
10092 -32657, /* A2 = 0.996613 */
10093 17491, /* B2 = 0.533783 */
10094 -12096, /* B1 = -0.738312 */
10095 17491, /* B0 = 0.533783 */
10096 5, /* Internal filter scaling */
10097 159, /* Minimum in-band energy threshold */
10098 21, /* 21/32 in-band to broad-band ratio */
10099 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10100 },
10101 { /* f1100_1750[] */
10102 12973, /* A1 = 0.79184 */
10103 -24916, /* A2 = -0.760376 */
10104 6655, /* B2 = 0.203102 */
10105 367, /* B1 = 0.0224 */
10106 6657, /* B0 = 0.203171 */
10107 5915, /* A1 = 0.361053 */
10108 -29560, /* A2 = -0.90213 */
10109 -7777, /* B2 = -0.23735 */
10110 0, /* B1 = 0 */
10111 7777, /* B0 = 0.23735 */
10112 20510, /* A1 = 1.251892 */
10113 -30260, /* A2 = -0.923462 */
10114 26662, /* B2 = 0.81366 */
10115 -20573, /* B1 = -1.255737 */
10116 26668, /* B0 = 0.813843 */
10117 7, /* Internal filter scaling */
10118 159, /* Minimum in-band energy threshold */
10119 21, /* 21/32 in-band to broad-band ratio */
10120 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10121 },
10122 { /* f1140 */
10123 20392, /* A1 = -1.244629 */
10124 -32460, /* A2 = 0.990601 */
10125 -270, /* B2 = -0.008240 */
10126 0, /* B1 = 0.000000 */
10127 270, /* B0 = 0.008240 */
10128 20218, /* A1 = -1.234009 */
10129 -32655, /* A2 = 0.996582 */
10130 21337, /* B2 = 0.651154 */
10131 -13044, /* B1 = -0.796143 */
10132 21337, /* B0 = 0.651154 */
10133 20684, /* A1 = -1.262512 */
10134 -32657, /* A2 = 0.996643 */
10135 8572, /* B2 = 0.261612 */
10136 -5476, /* B1 = -0.334244 */
10137 8572, /* B0 = 0.261612 */
10138 5, /* Internal filter scaling */
10139 159, /* Minimum in-band energy threshold */
10140 21, /* 21/32 in-band to broad-band ratio */
10141 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10142 },
10143 { /* f1200 */
10144 19159, /* A1 = -1.169373 */
10145 -32456, /* A2 = 0.990509 */
10146 -335, /* B2 = -0.010252 */
10147 0, /* B1 = 0.000000 */
10148 335, /* B0 = 0.010252 */
10149 18966, /* A1 = -1.157593 */
10150 -32661, /* A2 = 0.996735 */
10151 6802, /* B2 = 0.207588 */
10152 -3900, /* B1 = -0.238098 */
10153 6802, /* B0 = 0.207588 */
10154 19467, /* A1 = -1.188232 */
10155 -32661, /* A2 = 0.996765 */
10156 25035, /* B2 = 0.764008 */
10157 -15049, /* B1 = -0.918579 */
10158 25035, /* B0 = 0.764008 */
10159 5, /* Internal filter scaling */
10160 159, /* Minimum in-band energy threshold */
10161 21, /* 21/32 in-band to broad-band ratio */
10162 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10163 },
10164 { /* f1209 */
10165 18976, /* A1 = -1.158264 */
10166 -32439, /* A2 = 0.989990 */
10167 -183, /* B2 = -0.005588 */
10168 0, /* B1 = 0.000000 */
10169 183, /* B0 = 0.005588 */
10170 18774, /* A1 = -1.145874 */
10171 -32650, /* A2 = 0.996429 */
10172 15468, /* B2 = 0.472076 */
10173 -8768, /* B1 = -0.535217 */
10174 15468, /* B0 = 0.472076 */
10175 19300, /* A1 = -1.177979 */
10176 -32652, /* A2 = 0.996490 */
10177 19840, /* B2 = 0.605499 */
10178 -11842, /* B1 = -0.722809 */
10179 19840, /* B0 = 0.605499 */
10180 5, /* Internal filter scaling */
10181 159, /* Minimum in-band energy threshold */
10182 21, /* 21/32 in-band to broad-band ratio */
10183 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10184 },
10185 { /* f1330 */
10186 16357, /* A1 = -0.998413 */
10187 -32368, /* A2 = 0.987793 */
10188 -217, /* B2 = -0.006652 */
10189 0, /* B1 = 0.000000 */
10190 217, /* B0 = 0.006652 */
10191 16107, /* A1 = -0.983126 */
10192 -32601, /* A2 = 0.994904 */
10193 11602, /* B2 = 0.354065 */
10194 -5555, /* B1 = -0.339111 */
10195 11602, /* B0 = 0.354065 */
10196 16722, /* A1 = -1.020630 */
10197 -32603, /* A2 = 0.994965 */
10198 15574, /* B2 = 0.475311 */
10199 -8176, /* B1 = -0.499069 */
10200 15574, /* B0 = 0.475311 */
10201 5, /* Internal filter scaling */
10202 159, /* Minimum in-band energy threshold */
10203 21, /* 21/32 in-band to broad-band ratio */
10204 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10205 },
10206 { /* f1336 */
10207 16234, /* A1 = -0.990875 */
10208 32404, /* A2 = -0.988922 */
10209 -193, /* B2 = -0.005908 */
10210 0, /* B1 = 0.000000 */
10211 193, /* B0 = 0.005908 */
10212 15986, /* A1 = -0.975769 */
10213 -32632, /* A2 = 0.995880 */
10214 18051, /* B2 = 0.550903 */
10215 -8658, /* B1 = -0.528473 */
10216 18051, /* B0 = 0.550903 */
10217 16591, /* A1 = -1.012695 */
10218 -32634, /* A2 = 0.995941 */
10219 15736, /* B2 = 0.480240 */
10220 -8125, /* B1 = -0.495926 */
10221 15736, /* B0 = 0.480240 */
10222 5, /* Internal filter scaling */
10223 159, /* Minimum in-band energy threshold */
10224 21, /* 21/32 in-band to broad-band ratio */
10225 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10226 },
10227 { /* f1366 */
10228 15564, /* A1 = -0.949982 */
10229 -32404, /* A2 = 0.988922 */
10230 -269, /* B2 = -0.008216 */
10231 0, /* B1 = 0.000000 */
10232 269, /* B0 = 0.008216 */
10233 15310, /* A1 = -0.934479 */
10234 -32632, /* A2 = 0.995880 */
10235 10815, /* B2 = 0.330063 */
10236 -4962, /* B1 = -0.302887 */
10237 10815, /* B0 = 0.330063 */
10238 15924, /* A1 = -0.971924 */
10239 -32634, /* A2 = 0.995941 */
10240 18880, /* B2 = 0.576172 */
10241 -9364, /* B1 = -0.571594 */
10242 18880, /* B0 = 0.576172 */
10243 5, /* Internal filter scaling */
10244 159, /* Minimum in-band energy threshold */
10245 21, /* 21/32 in-band to broad-band ratio */
10246 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10247 },
10248 { /* f1380 */
10249 15247, /* A1 = -0.930603 */
10250 -32397, /* A2 = 0.988708 */
10251 -244, /* B2 = -0.007451 */
10252 0, /* B1 = 0.000000 */
10253 244, /* B0 = 0.007451 */
10254 14989, /* A1 = -0.914886 */
10255 -32627, /* A2 = 0.995697 */
10256 18961, /* B2 = 0.578644 */
10257 -8498, /* B1 = -0.518707 */
10258 18961, /* B0 = 0.578644 */
10259 15608, /* A1 = -0.952667 */
10260 -32628, /* A2 = 0.995758 */
10261 11145, /* B2 = 0.340134 */
10262 -5430, /* B1 = -0.331467 */
10263 11145, /* B0 = 0.340134 */
10264 5, /* Internal filter scaling */
10265 159, /* Minimum in-band energy threshold */
10266 21, /* 21/32 in-band to broad-band ratio */
10267 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10268 },
10269 { /* f1400 */
10270 14780, /* A1 = -0.902130 */
10271 -32393, /* A2 = 0.988586 */
10272 -396, /* B2 = -0.012086 */
10273 0, /* B1 = 0.000000 */
10274 396, /* B0 = 0.012086 */
10275 14510, /* A1 = -0.885651 */
10276 -32630, /* A2 = 0.995819 */
10277 6326, /* B2 = 0.193069 */
10278 -2747, /* B1 = -0.167671 */
10279 6326, /* B0 = 0.193069 */
10280 15154, /* A1 = -0.924957 */
10281 -32632, /* A2 = 0.995850 */
10282 23235, /* B2 = 0.709076 */
10283 -10983, /* B1 = -0.670380 */
10284 23235, /* B0 = 0.709076 */
10285 5, /* Internal filter scaling */
10286 159, /* Minimum in-band energy threshold */
10287 21, /* 21/32 in-band to broad-band ratio */
10288 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10289 },
10290 { /* f1477 */
10291 13005, /* A1 = -0.793793 */
10292 -32368, /* A2 = 0.987823 */
10293 -500, /* B2 = -0.015265 */
10294 0, /* B1 = 0.000000 */
10295 500, /* B0 = 0.015265 */
10296 12708, /* A1 = -0.775665 */
10297 -32615, /* A2 = 0.995331 */
10298 11420, /* B2 = 0.348526 */
10299 -4306, /* B1 = -0.262833 */
10300 11420, /* B0 = 0.348526 */
10301 13397, /* A1 = -0.817688 */
10302 -32615, /* A2 = 0.995361 */
10303 9454, /* B2 = 0.288528 */
10304 -3981, /* B1 = -0.243027 */
10305 9454, /* B0 = 0.288528 */
10306 5, /* Internal filter scaling */
10307 159, /* Minimum in-band energy threshold */
10308 21, /* 21/32 in-band to broad-band ratio */
10309 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10310 },
10311 { /* f1600 */
10312 10046, /* A1 = -0.613190 */
10313 -32331, /* A2 = 0.986694 */
10314 -455, /* B2 = -0.013915 */
10315 0, /* B1 = 0.000000 */
10316 455, /* B0 = 0.013915 */
10317 9694, /* A1 = -0.591705 */
10318 -32601, /* A2 = 0.994934 */
10319 6023, /* B2 = 0.183815 */
10320 -1708, /* B1 = -0.104279 */
10321 6023, /* B0 = 0.183815 */
10322 10478, /* A1 = -0.639587 */
10323 -32603, /* A2 = 0.994965 */
10324 22031, /* B2 = 0.672333 */
10325 -7342, /* B1 = -0.448151 */
10326 22031, /* B0 = 0.672333 */
10327 5, /* Internal filter scaling */
10328 159, /* Minimum in-band energy threshold */
10329 21, /* 21/32 in-band to broad-band ratio */
10330 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10331 },
10332 { /* f1633_1638[] */
10333 9181, /* A1 = 0.560394 */
10334 -32256, /* A2 = -0.984375 */
10335 -556, /* B2 = -0.016975 */
10336 0, /* B1 = 0 */
10337 556, /* B0 = 0.016975 */
10338 8757, /* A1 = 0.534515 */
10339 -32574, /* A2 = -0.99408 */
10340 8443, /* B2 = 0.25769 */
10341 -2135, /* B1 = -0.130341 */
10342 8443, /* B0 = 0.25769 */
10343 9691, /* A1 = 0.591522 */
10344 -32574, /* A2 = -0.99411 */
10345 15446, /* B2 = 0.471375 */
10346 -4809, /* B1 = -0.293579 */
10347 15446, /* B0 = 0.471375 */
10348 7, /* Internal filter scaling */
10349 159, /* Minimum in-band energy threshold */
10350 21, /* 21/32 in-band to broad-band ratio */
10351 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10352 },
10353 { /* f1800 */
10354 5076, /* A1 = -0.309875 */
10355 -32304, /* A2 = 0.985840 */
10356 -508, /* B2 = -0.015503 */
10357 0, /* B1 = 0.000000 */
10358 508, /* B0 = 0.015503 */
10359 4646, /* A1 = -0.283600 */
10360 -32605, /* A2 = 0.995026 */
10361 6742, /* B2 = 0.205780 */
10362 -878, /* B1 = -0.053635 */
10363 6742, /* B0 = 0.205780 */
10364 5552, /* A1 = -0.338928 */
10365 -32605, /* A2 = 0.995056 */
10366 23667, /* B2 = 0.722260 */
10367 -4297, /* B1 = -0.262329 */
10368 23667, /* B0 = 0.722260 */
10369 5, /* Internal filter scaling */
10370 159, /* Minimum in-band energy threshold */
10371 21, /* 21/32 in-band to broad-band ratio */
10372 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10373 },
10374 { /* f1860 */
10375 3569, /* A1 = -0.217865 */
10376 -32292, /* A2 = 0.985504 */
10377 -239, /* B2 = -0.007322 */
10378 0, /* B1 = 0.000000 */
10379 239, /* B0 = 0.007322 */
10380 3117, /* A1 = -0.190277 */
10381 -32603, /* A2 = 0.994965 */
10382 18658, /* B2 = 0.569427 */
10383 -1557, /* B1 = -0.095032 */
10384 18658, /* B0 = 0.569427 */
10385 4054, /* A1 = -0.247437 */
10386 -32603, /* A2 = 0.994965 */
10387 18886, /* B2 = 0.576385 */
10388 -2566, /* B1 = -0.156647 */
10389 18886, /* B0 = 0.576385 */
10390 5, /* Internal filter scaling */
10391 159, /* Minimum in-band energy threshold */
10392 21, /* 21/32 in-band to broad-band ratio */
10393 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10394 },
10395 };
10396 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10397 {
10398 unsigned short cmd;
10399 int cnt, max;
10400
10401 if (jf->filter > 3) {
10402 return -1;
10403 }
10404 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10405
10406 return -1;
10407 if (!jf->enable) {
10408 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10409
10410 return -1;
10411 else
10412 return 0;
10413 } else {
10414 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10415
10416 return -1;
10417 /* Select the filter (f0 - f3) to use. */
10418 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10419 return -1;
10420 }
10421 if (jf->freq < 12 && jf->freq > 3) {
10422 /* Select the frequency for the selected filter. */
10423 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10424 return -1;
10425 } else if (jf->freq > 11) {
10426 /* We need to load a programmable filter set for undefined */
10427 /* frequencies. So we will point the filter to a programmable set. */
10428 /* Since there are only 4 filters and 4 programmable sets, we will */
10429 /* just point the filter to the same number set and program it for the */
10430 /* frequency we want. */
10431 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10432 return -1;
10433 if (j->ver.low != 0x12) {
10434 cmd = 0x515B;
10435 max = 19;
10436 } else {
10437 cmd = 0x515E;
10438 max = 15;
10439 }
10440 if (ixj_WriteDSPCommand(cmd, j))
10441 return -1;
10442 for (cnt = 0; cnt < max; cnt++) {
10443 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10444 return -1;
10445 }
10446 }
10447 j->filter_en[jf->filter] = jf->enable;
10448 return 0;
10449 }
10450
10451 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10452 {
10453 unsigned short cmd;
10454 int cnt, max;
10455 if (jfr->filter > 3) {
10456 return -1;
10457 }
10458 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10459 return -1;
10460
10461 if (!jfr->enable) {
10462 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10463 return -1;
10464 else
10465 return 0;
10466 } else {
10467 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10468 return -1;
10469 /* Select the filter (f0 - f3) to use. */
10470 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10471 return -1;
10472 }
10473 /* We need to load a programmable filter set for undefined */
10474 /* frequencies. So we will point the filter to a programmable set. */
10475 /* Since there are only 4 filters and 4 programmable sets, we will */
10476 /* just point the filter to the same number set and program it for the */
10477 /* frequency we want. */
10478 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10479 return -1;
10480 if (j->ver.low != 0x12) {
10481 cmd = 0x515B;
10482 max = 19;
10483 } else {
10484 cmd = 0x515E;
10485 max = 15;
10486 }
10487 if (ixj_WriteDSPCommand(cmd, j))
10488 return -1;
10489 for (cnt = 0; cnt < max; cnt++) {
10490 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10491 return -1;
10492 }
10493 j->filter_en[jfr->filter] = jfr->enable;
10494 return 0;
10495 }
10496
10497 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10498 {
10499 int freq0, freq1;
10500 unsigned short data;
10501 if (ti->freq0) {
10502 freq0 = ti->freq0;
10503 } else {
10504 freq0 = 0x7FFF;
10505 }
10506
10507 if (ti->freq1) {
10508 freq1 = ti->freq1;
10509 } else {
10510 freq1 = 0x7FFF;
10511 }
10512
10513 if(ti->tone_index > 12 && ti->tone_index < 28)
10514 {
10515 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10516 return -1;
10517 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10518 return -1;
10519 data = freq0;
10520 if (ixj_WriteDSPCommand(data, j))
10521 return -1;
10522 data = freq1;
10523 if (ixj_WriteDSPCommand(data, j))
10524 return -1;
10525 }
10526 return freq0;
10527 }
10528
linux kernel for loongson