?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: Gumstix Verdex PCMCIA support
[linux-2.6/verdex.git] / drivers / telephony / ixj.c
blob40de151f27898a1e20b82f22d80ccbc9448be558
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 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
46 * Audit some copy_*_user and minor cleanup.
47 *
48 * Revision 4.7 2001/08/13 06:19:33 craigs
49 * Added additional changes from Alan Cox and John Anderson for
50 * 2.2 to 2.4 cleanup and bounds checking
51 *
52 * Revision 4.6 2001/08/13 01:05:05 craigs
53 * Really fixed PHONE_QUERY_CODEC problem this time
54 *
55 * Revision 4.5 2001/08/13 00:11:03 craigs
56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57 *
58 * Revision 4.4 2001/08/07 07:58:12 craigs
59 * Changed back to three digit version numbers
60 * Added tagbuild target to allow automatic and easy tagging of versions
61 *
62 * Revision 4.3 2001/08/07 07:24:47 craigs
63 * Added ixj-ver.h to allow easy configuration management of driver
64 * Added display of version number in /prox/ixj
65 *
66 * Revision 4.2 2001/08/06 07:07:19 craigs
67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68 * behaviour of returning int rather than short *
69 *
70 * Revision 4.1 2001/08/05 00:17:37 craigs
71 * More changes for correct PCMCIA installation
72 * Start of changes for backward Linux compatibility
73 *
74 * Revision 4.0 2001/08/04 12:33:12 craigs
75 * New version using GNU autoconf
76 *
77 * Revision 3.105 2001/07/20 23:14:32 eokerson
78 * More work on CallerID generation when using ring cadences.
79 *
80 * Revision 3.104 2001/07/06 01:33:55 eokerson
81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
82 *
83 * Revision 3.103 2001/07/05 19:20:16 eokerson
84 * Updated HOWTO
85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86 *
87 * Revision 3.102 2001/07/03 23:51:21 eokerson
88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
89 *
90 * Revision 3.101 2001/07/02 19:26:56 eokerson
91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92 *
93 * Revision 3.100 2001/07/02 19:18:27 eokerson
94 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96 * Fixed speaker mode on Internet LineJACK.
97 *
98 * Revision 3.99 2001/05/09 14:11:16 eokerson
99 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
100 *
101 * Revision 3.98 2001/05/08 19:55:33 eokerson
102 * Fixed POTS hookstate detection while it is connected to PSTN port.
103 *
104 * Revision 3.97 2001/05/08 00:01:04 eokerson
105 * Fixed kernel oops when sending caller ID data.
106 *
107 * Revision 3.96 2001/05/04 23:09:30 eokerson
108 * Now uses one kernel timer for each card, instead of one for the entire driver.
109 *
110 * Revision 3.95 2001/04/25 22:06:47 eokerson
111 * Fixed squawking at beginning of some G.723.1 calls.
112 *
113 * Revision 3.94 2001/04/03 23:42:00 eokerson
114 * Added linear volume ioctls
115 * Added raw filter load ioctl
116 *
117 * Revision 3.93 2001/02/27 01:00:06 eokerson
118 * Fixed blocking in CallerID.
119 * Reduced size of ixj structure for smaller driver footprint.
120 *
121 * Revision 3.92 2001/02/20 22:02:59 eokerson
122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123 * Improved PSTN ring detection.
124 * Fixed wink generation on POTS ports.
125 *
126 * Revision 3.91 2001/02/13 00:55:44 eokerson
127 * Turn AEC back on after changing frame sizes.
128 *
129 * Revision 3.90 2001/02/12 16:42:00 eokerson
130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131 *
132 * Revision 3.89 2001/02/12 15:41:16 eokerson
133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
134 *
135 * Revision 3.88 2001/02/05 23:25:42 eokerson
136 * Fixed lockup bugs with deregister.
137 *
138 * Revision 3.87 2001/01/29 21:00:39 eokerson
139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
140 * Updated copyright date.
141 *
142 * Revision 3.86 2001/01/23 23:53:46 eokerson
143 * Fixes to G.729 compatibility.
144 *
145 * Revision 3.85 2001/01/23 21:30:36 eokerson
146 * Added verbage about cards supported.
147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148 *
149 * Revision 3.84 2001/01/22 23:32:10 eokerson
150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
151 *
152 * Revision 3.83 2001/01/19 14:51:41 eokerson
153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154 *
155 * Revision 3.82 2001/01/19 00:34:49 eokerson
156 * Added verbosity to write overlap errors.
157 *
158 * Revision 3.81 2001/01/18 23:56:54 eokerson
159 * Fixed PSTN line test functions.
160 *
161 * Revision 3.80 2001/01/18 22:29:27 eokerson
162 * Updated AEC/AGC values for different cards.
163 *
164 * Revision 3.79 2001/01/17 02:58:54 eokerson
165 * Fixed AEC reset after Caller ID.
166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167 *
168 * Revision 3.78 2001/01/16 19:43:09 eokerson
169 * Added support for Linux 2.4.x kernels.
170 *
171 * Revision 3.77 2001/01/09 04:00:52 eokerson
172 * Linetest will now test the line, even if it has previously succeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246 #include "ixj-ver.h"
247
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251
252 #include <linux/module.h>
253
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/smp_lock.h>
261 #include <linux/mm.h>
262 #include <linux/ioport.h>
263 #include <linux/interrupt.h>
264 #include <linux/proc_fs.h>
265 #include <linux/poll.h>
266 #include <linux/timer.h>
267 #include <linux/delay.h>
268 #include <linux/pci.h>
269
270 #include <asm/io.h>
271 #include <asm/uaccess.h>
272
273 #include <linux/isapnp.h>
274
275 #include "ixj.h"
276
277 #define TYPE(inode) (iminor(inode) >> 4)
278 #define NUM(inode) (iminor(inode) & 0xf)
279
280 static int ixjdebug;
281 static int hertz = HZ;
282 static int samplerate = 100;
283
284 module_param(ixjdebug, int, 0);
285
286 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
287 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
288 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
289 { }
290 };
291
292 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
293
294 /************************************************************************
295 *
296 * ixjdebug meanings are now bit mapped instead of level based
297 * Values can be or'ed together to turn on multiple messages
298 *
299 * bit 0 (0x0001) = any failure
300 * bit 1 (0x0002) = general messages
301 * bit 2 (0x0004) = POTS ringing related
302 * bit 3 (0x0008) = PSTN events
303 * bit 4 (0x0010) = PSTN Cadence state details
304 * bit 5 (0x0020) = Tone detection triggers
305 * bit 6 (0x0040) = Tone detection cadence details
306 * bit 7 (0x0080) = ioctl tracking
307 * bit 8 (0x0100) = signal tracking
308 * bit 9 (0x0200) = CallerID generation details
309 *
310 ************************************************************************/
311
312 #ifdef IXJ_DYN_ALLOC
313
314 static IXJ *ixj[IXJMAX];
315 #define get_ixj(b) ixj[(b)]
316
317 /*
318 * Allocate a free IXJ device
319 */
320
321 static IXJ *ixj_alloc()
322 {
323 for(cnt=0; cnt<IXJMAX; cnt++)
324 {
325 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
326 {
327 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
328 if (j == NULL)
329 return NULL;
330 ixj[cnt] = j;
331 return j;
332 }
333 }
334 return NULL;
335 }
336
337 static void ixj_fsk_free(IXJ *j)
338 {
339 kfree(j->fskdata);
340 j->fskdata = NULL;
341 }
342
343 static void ixj_fsk_alloc(IXJ *j)
344 {
345 if(!j->fskdata) {
346 j->fskdata = kmalloc(8000, GFP_KERNEL);
347 if (!j->fskdata) {
348 if(ixjdebug & 0x0200) {
349 printk("IXJ phone%d - allocate failed\n", j->board);
350 }
351 return;
352 } else {
353 j->fsksize = 8000;
354 if(ixjdebug & 0x0200) {
355 printk("IXJ phone%d - allocate succeded\n", j->board);
356 }
357 }
358 }
359 }
360
361 #else
362
363 static IXJ ixj[IXJMAX];
364 #define get_ixj(b) (&ixj[(b)])
365
366 /*
367 * Allocate a free IXJ device
368 */
369
370 static IXJ *ixj_alloc(void)
371 {
372 int cnt;
373 for(cnt=0; cnt<IXJMAX; cnt++) {
374 if(!ixj[cnt].DSPbase)
375 return &ixj[cnt];
376 }
377 return NULL;
378 }
379
380 static inline void ixj_fsk_free(IXJ *j) {;}
381
382 static inline void ixj_fsk_alloc(IXJ *j)
383 {
384 j->fsksize = 8000;
385 }
386
387 #endif
388
389 #ifdef PERFMON_STATS
390 #define ixj_perfmon(x) ((x)++)
391 #else
392 #define ixj_perfmon(x) do { } while(0)
393 #endif
394
395 static int ixj_convert_loaded;
396
397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
398
399 /************************************************************************
400 *
401 * These are function definitions to allow external modules to register
402 * enhanced functionality call backs.
403 *
404 ************************************************************************/
405
406 static int Stub(IXJ * J, unsigned long arg)
407 {
408 return 0;
409 }
410
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415
416 static void ixj_read_frame(IXJ *j);
417 static void ixj_write_frame(IXJ *j);
418 static void ixj_init_timer(IXJ *j);
419 static void ixj_add_timer(IXJ * j);
420 static void ixj_timeout(unsigned long ptr);
421 static int read_filters(IXJ *j);
422 static int LineMonitor(IXJ *j);
423 static int ixj_fasync(int fd, struct file *, int mode);
424 static int ixj_set_port(IXJ *j, int arg);
425 static int ixj_set_pots(IXJ *j, int arg);
426 static int ixj_hookstate(IXJ *j);
427 static int ixj_record_start(IXJ *j);
428 static void ixj_record_stop(IXJ *j);
429 static void set_rec_volume(IXJ *j, int volume);
430 static int get_rec_volume(IXJ *j);
431 static int set_rec_codec(IXJ *j, int rate);
432 static void ixj_vad(IXJ *j, int arg);
433 static int ixj_play_start(IXJ *j);
434 static void ixj_play_stop(IXJ *j);
435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
436 static int ixj_set_tone_off(unsigned short, IXJ *j);
437 static int ixj_play_tone(IXJ *j, char tone);
438 static void ixj_aec_start(IXJ *j, int level);
439 static int idle(IXJ *j);
440 static void ixj_ring_on(IXJ *j);
441 static void ixj_ring_off(IXJ *j);
442 static void aec_stop(IXJ *j);
443 static void ixj_ringback(IXJ *j);
444 static void ixj_busytone(IXJ *j);
445 static void ixj_dialtone(IXJ *j);
446 static void ixj_cpt_stop(IXJ *j);
447 static char daa_int_read(IXJ *j);
448 static char daa_CR_read(IXJ *j, int cr);
449 static int daa_set_mode(IXJ *j, int mode);
450 static int ixj_linetest(IXJ *j);
451 static int ixj_daa_write(IXJ *j);
452 static int ixj_daa_cid_read(IXJ *j);
453 static void DAA_Coeff_US(IXJ *j);
454 static void DAA_Coeff_UK(IXJ *j);
455 static void DAA_Coeff_France(IXJ *j);
456 static void DAA_Coeff_Germany(IXJ *j);
457 static void DAA_Coeff_Australia(IXJ *j);
458 static void DAA_Coeff_Japan(IXJ *j);
459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
464 /* Serial Control Interface funtions */
465 static int SCI_Control(IXJ *j, int control);
466 static int SCI_Prepare(IXJ *j);
467 static int SCI_WaitHighSCI(IXJ *j);
468 static int SCI_WaitLowSCI(IXJ *j);
469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
470 static int ixj_PCcontrol_wait(IXJ *j);
471 static void ixj_pre_cid(IXJ *j);
472 static void ixj_write_cid(IXJ *j);
473 static void ixj_write_cid_bit(IXJ *j, int bit);
474 static int set_base_frame(IXJ *j, int size);
475 static int set_play_codec(IXJ *j, int rate);
476 static void set_rec_depth(IXJ *j, int depth);
477 static int ixj_mixer(long val, IXJ *j);
478
479 /************************************************************************
480 CT8020/CT8021 Host Programmers Model
481 Host address Function Access
482 DSPbase +
483 0-1 Aux Software Status Register (reserved) Read Only
484 2-3 Software Status Register Read Only
485 4-5 Aux Software Control Register (reserved) Read Write
486 6-7 Software Control Register Read Write
487 8-9 Hardware Status Register Read Only
488 A-B Hardware Control Register Read Write
489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
490 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
491 ************************************************************************/
492
493 static inline void ixj_read_HSR(IXJ *j)
494 {
495 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
496 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
497 }
498
499 static inline int IsControlReady(IXJ *j)
500 {
501 ixj_read_HSR(j);
502 return j->hsr.bits.controlrdy ? 1 : 0;
503 }
504
505 static inline int IsPCControlReady(IXJ *j)
506 {
507 j->pccr1.byte = inb_p(j->XILINXbase + 3);
508 return j->pccr1.bits.crr ? 1 : 0;
509 }
510
511 static inline int IsStatusReady(IXJ *j)
512 {
513 ixj_read_HSR(j);
514 return j->hsr.bits.statusrdy ? 1 : 0;
515 }
516
517 static inline int IsRxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->rxreadycheck);
521 return j->hsr.bits.rxrdy ? 1 : 0;
522 }
523
524 static inline int IsTxReady(IXJ *j)
525 {
526 ixj_read_HSR(j);
527 ixj_perfmon(j->txreadycheck);
528 return j->hsr.bits.txrdy ? 1 : 0;
529 }
530
531 static inline void set_play_volume(IXJ *j, int volume)
532 {
533 if (ixjdebug & 0x0002)
534 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
535 ixj_WriteDSPCommand(0xCF02, j);
536 ixj_WriteDSPCommand(volume, j);
537 }
538
539 static int set_play_volume_linear(IXJ *j, int volume)
540 {
541 int newvolume, dspplaymax;
542
543 if (ixjdebug & 0x0002)
544 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
545 if(volume > 100 || volume < 0) {
546 return -1;
547 }
548
549 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
550 switch (j->cardtype) {
551 case QTI_PHONEJACK:
552 dspplaymax = 0x380;
553 break;
554 case QTI_LINEJACK:
555 if(j->port == PORT_PSTN) {
556 dspplaymax = 0x48;
557 } else {
558 dspplaymax = 0x100;
559 }
560 break;
561 case QTI_PHONEJACK_LITE:
562 dspplaymax = 0x380;
563 break;
564 case QTI_PHONEJACK_PCI:
565 dspplaymax = 0x6C;
566 break;
567 case QTI_PHONECARD:
568 dspplaymax = 0x50;
569 break;
570 default:
571 return -1;
572 }
573 newvolume = (dspplaymax * volume) / 100;
574 set_play_volume(j, newvolume);
575 return 0;
576 }
577
578 static inline void set_play_depth(IXJ *j, int depth)
579 {
580 if (depth > 60)
581 depth = 60;
582 if (depth < 0)
583 depth = 0;
584 ixj_WriteDSPCommand(0x5280 + depth, j);
585 }
586
587 static inline int get_play_volume(IXJ *j)
588 {
589 ixj_WriteDSPCommand(0xCF00, j);
590 return j->ssr.high << 8 | j->ssr.low;
591 }
592
593 static int get_play_volume_linear(IXJ *j)
594 {
595 int volume, newvolume, dspplaymax;
596
597 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
598 switch (j->cardtype) {
599 case QTI_PHONEJACK:
600 dspplaymax = 0x380;
601 break;
602 case QTI_LINEJACK:
603 if(j->port == PORT_PSTN) {
604 dspplaymax = 0x48;
605 } else {
606 dspplaymax = 0x100;
607 }
608 break;
609 case QTI_PHONEJACK_LITE:
610 dspplaymax = 0x380;
611 break;
612 case QTI_PHONEJACK_PCI:
613 dspplaymax = 0x6C;
614 break;
615 case QTI_PHONECARD:
616 dspplaymax = 100;
617 break;
618 default:
619 return -1;
620 }
621 volume = get_play_volume(j);
622 newvolume = (volume * 100) / dspplaymax;
623 if(newvolume > 100)
624 newvolume = 100;
625 return newvolume;
626 }
627
628 static inline BYTE SLIC_GetState(IXJ *j)
629 {
630 if (j->cardtype == QTI_PHONECARD) {
631 j->pccr1.byte = 0;
632 j->psccr.bits.dev = 3;
633 j->psccr.bits.rw = 1;
634 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
635 ixj_PCcontrol_wait(j);
636 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
637 ixj_PCcontrol_wait(j);
638 if (j->pslic.bits.powerdown)
639 return PLD_SLIC_STATE_OC;
640 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
641 return PLD_SLIC_STATE_ACTIVE;
642 else
643 return PLD_SLIC_STATE_RINGING;
644 } else {
645 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
646 }
647 return j->pld_slicr.bits.state;
648 }
649
650 static bool SLIC_SetState(BYTE byState, IXJ *j)
651 {
652 bool fRetVal = false;
653
654 if (j->cardtype == QTI_PHONECARD) {
655 if (j->flags.pcmciasct) {
656 switch (byState) {
657 case PLD_SLIC_STATE_TIPOPEN:
658 case PLD_SLIC_STATE_OC:
659 j->pslic.bits.powerdown = 1;
660 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
661 fRetVal = true;
662 break;
663 case PLD_SLIC_STATE_RINGING:
664 if (j->readers || j->writers) {
665 j->pslic.bits.powerdown = 0;
666 j->pslic.bits.ring0 = 1;
667 j->pslic.bits.ring1 = 0;
668 fRetVal = true;
669 }
670 break;
671 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
672
673 case PLD_SLIC_STATE_STANDBY:
674 case PLD_SLIC_STATE_ACTIVE:
675 if (j->readers || j->writers) {
676 j->pslic.bits.powerdown = 0;
677 } else {
678 j->pslic.bits.powerdown = 1;
679 }
680 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
681 fRetVal = true;
682 break;
683 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
684
685 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
686
687 default:
688 fRetVal = false;
689 break;
690 }
691 j->psccr.bits.dev = 3;
692 j->psccr.bits.rw = 0;
693 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
694 ixj_PCcontrol_wait(j);
695 }
696 } else {
697 /* Set the C1, C2, C3 & B2EN signals. */
698 switch (byState) {
699 case PLD_SLIC_STATE_OC:
700 j->pld_slicw.bits.c1 = 0;
701 j->pld_slicw.bits.c2 = 0;
702 j->pld_slicw.bits.c3 = 0;
703 j->pld_slicw.bits.b2en = 0;
704 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
705 fRetVal = true;
706 break;
707 case PLD_SLIC_STATE_RINGING:
708 j->pld_slicw.bits.c1 = 1;
709 j->pld_slicw.bits.c2 = 0;
710 j->pld_slicw.bits.c3 = 0;
711 j->pld_slicw.bits.b2en = 1;
712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
713 fRetVal = true;
714 break;
715 case PLD_SLIC_STATE_ACTIVE:
716 j->pld_slicw.bits.c1 = 0;
717 j->pld_slicw.bits.c2 = 1;
718 j->pld_slicw.bits.c3 = 0;
719 j->pld_slicw.bits.b2en = 0;
720 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
721 fRetVal = true;
722 break;
723 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
724
725 j->pld_slicw.bits.c1 = 1;
726 j->pld_slicw.bits.c2 = 1;
727 j->pld_slicw.bits.c3 = 0;
728 j->pld_slicw.bits.b2en = 0;
729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
730 fRetVal = true;
731 break;
732 case PLD_SLIC_STATE_TIPOPEN:
733 j->pld_slicw.bits.c1 = 0;
734 j->pld_slicw.bits.c2 = 0;
735 j->pld_slicw.bits.c3 = 1;
736 j->pld_slicw.bits.b2en = 0;
737 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
738 fRetVal = true;
739 break;
740 case PLD_SLIC_STATE_STANDBY:
741 j->pld_slicw.bits.c1 = 1;
742 j->pld_slicw.bits.c2 = 0;
743 j->pld_slicw.bits.c3 = 1;
744 j->pld_slicw.bits.b2en = 1;
745 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
746 fRetVal = true;
747 break;
748 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
749
750 j->pld_slicw.bits.c1 = 0;
751 j->pld_slicw.bits.c2 = 1;
752 j->pld_slicw.bits.c3 = 1;
753 j->pld_slicw.bits.b2en = 0;
754 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
755 fRetVal = true;
756 break;
757 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
758
759 j->pld_slicw.bits.c1 = 1;
760 j->pld_slicw.bits.c2 = 1;
761 j->pld_slicw.bits.c3 = 1;
762 j->pld_slicw.bits.b2en = 0;
763 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
764 fRetVal = true;
765 break;
766 default:
767 fRetVal = false;
768 break;
769 }
770 }
771
772 return fRetVal;
773 }
774
775 static int ixj_wink(IXJ *j)
776 {
777 BYTE slicnow;
778
779 slicnow = SLIC_GetState(j);
780
781 j->pots_winkstart = jiffies;
782 SLIC_SetState(PLD_SLIC_STATE_OC, j);
783
784 msleep(jiffies_to_msecs(j->winktime));
785
786 SLIC_SetState(slicnow, j);
787 return 0;
788 }
789
790 static void ixj_init_timer(IXJ *j)
791 {
792 init_timer(&j->timer);
793 j->timer.function = ixj_timeout;
794 j->timer.data = (unsigned long)j;
795 }
796
797 static void ixj_add_timer(IXJ *j)
798 {
799 j->timer.expires = jiffies + (hertz / samplerate);
800 add_timer(&j->timer);
801 }
802
803 static void ixj_tone_timeout(IXJ *j)
804 {
805 IXJ_TONE ti;
806
807 j->tone_state++;
808 if (j->tone_state == 3) {
809 j->tone_state = 0;
810 if (j->cadence_t) {
811 j->tone_cadence_state++;
812 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
813 switch (j->cadence_t->termination) {
814 case PLAY_ONCE:
815 ixj_cpt_stop(j);
816 break;
817 case REPEAT_LAST_ELEMENT:
818 j->tone_cadence_state--;
819 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
820 break;
821 case REPEAT_ALL:
822 j->tone_cadence_state = 0;
823 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
824 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
825 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
826 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
827 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
828 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
829 ixj_init_tone(j, &ti);
830 }
831 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
832 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
833 ixj_play_tone(j, j->cadence_t->ce[0].index);
834 break;
835 }
836 } else {
837 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
838 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
839 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
840 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
841 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
842 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
843 ixj_init_tone(j, &ti);
844 }
845 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
846 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
847 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
848 }
849 }
850 }
851 }
852
853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
854 {
855 if(j->ixj_signals[event]) {
856 if(ixjdebug & 0x0100)
857 printk("Sending signal for event %d\n", event);
858 /* Send apps notice of change */
859 /* see config.h for macro definition */
860 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
861 }
862 }
863
864 static void ixj_pstn_state(IXJ *j)
865 {
866 int var;
867 union XOPXR0 XR0, daaint;
868
869 var = 10;
870
871 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
872 daaint.reg = 0;
873 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
874
875 j->pld_scrr.byte = inb_p(j->XILINXbase);
876 if (j->pld_scrr.bits.daaflag) {
877 daa_int_read(j);
878 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
879 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
880 daaint.bitreg.RING = 1;
881 if(ixjdebug & 0x0008) {
882 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
883 }
884 } else {
885 daa_set_mode(j, SOP_PU_RESET);
886 }
887 }
888 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
889 daaint.bitreg.Caller_ID = 1;
890 j->pstn_cid_intr = 1;
891 j->pstn_cid_received = jiffies;
892 if(ixjdebug & 0x0008) {
893 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
894 }
895 }
896 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
897 daaint.bitreg.Cadence = 1;
898 if(ixjdebug & 0x0008) {
899 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
900 }
901 }
902 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
903 daaint.bitreg.VDD_OK = 1;
904 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
905 }
906 }
907 daa_CR_read(j, 1);
908 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
909 daaint.bitreg.RMR = 1;
910 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
911 if(ixjdebug & 0x0008) {
912 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
913 }
914 j->pstn_prev_rmr = j->pstn_last_rmr;
915 j->pstn_last_rmr = jiffies;
916 }
917 switch(j->daa_mode) {
918 case SOP_PU_SLEEP:
919 if (daaint.bitreg.RING) {
920 if (!j->flags.pstn_ringing) {
921 if (j->daa_mode != SOP_PU_RINGING) {
922 j->pstn_ring_int = jiffies;
923 daa_set_mode(j, SOP_PU_RINGING);
924 }
925 }
926 }
927 break;
928 case SOP_PU_RINGING:
929 if (daaint.bitreg.RMR) {
930 if (ixjdebug & 0x0008) {
931 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
932 }
933 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
934 j->flags.pstn_rmr = 1;
935 j->pstn_ring_start = jiffies;
936 j->pstn_ring_stop = 0;
937 j->ex.bits.pstn_ring = 0;
938 if (j->cadence_f[4].state == 0) {
939 j->cadence_f[4].state = 1;
940 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
941 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
942 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
943 } else if (j->cadence_f[4].state == 2) {
944 if((time_after(jiffies, j->cadence_f[4].off1min) &&
945 time_before(jiffies, j->cadence_f[4].off1max))) {
946 if (j->cadence_f[4].on2) {
947 j->cadence_f[4].state = 3;
948 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
949 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
950 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
951 } else {
952 j->cadence_f[4].state = 7;
953 }
954 } else {
955 if (ixjdebug & 0x0008) {
956 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
957 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
958 j->cadence_f[4].off1);
959 }
960 j->cadence_f[4].state = 0;
961 }
962 } else if (j->cadence_f[4].state == 4) {
963 if((time_after(jiffies, j->cadence_f[4].off2min) &&
964 time_before(jiffies, j->cadence_f[4].off2max))) {
965 if (j->cadence_f[4].on3) {
966 j->cadence_f[4].state = 5;
967 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
968 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
969 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
970 } else {
971 j->cadence_f[4].state = 7;
972 }
973 } else {
974 if (ixjdebug & 0x0008) {
975 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
976 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
977 j->cadence_f[4].off2);
978 }
979 j->cadence_f[4].state = 0;
980 }
981 } else if (j->cadence_f[4].state == 6) {
982 if((time_after(jiffies, j->cadence_f[4].off3min) &&
983 time_before(jiffies, j->cadence_f[4].off3max))) {
984 j->cadence_f[4].state = 7;
985 } else {
986 if (ixjdebug & 0x0008) {
987 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
988 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
989 j->cadence_f[4].off3);
990 }
991 j->cadence_f[4].state = 0;
992 }
993 } else {
994 j->cadence_f[4].state = 0;
995 }
996 } else { /* Falling edge of RMR */
997 j->pstn_ring_start = 0;
998 j->pstn_ring_stop = jiffies;
999 if (j->cadence_f[4].state == 1) {
1000 if(!j->cadence_f[4].on1) {
1001 j->cadence_f[4].state = 7;
1002 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003 time_before(jiffies, j->cadence_f[4].on1max))) {
1004 if (j->cadence_f[4].off1) {
1005 j->cadence_f[4].state = 2;
1006 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009 } else {
1010 j->cadence_f[4].state = 7;
1011 }
1012 } else {
1013 if (ixjdebug & 0x0008) {
1014 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016 j->cadence_f[4].on1);
1017 }
1018 j->cadence_f[4].state = 0;
1019 }
1020 } else if (j->cadence_f[4].state == 3) {
1021 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022 time_before(jiffies, j->cadence_f[4].on2max))) {
1023 if (j->cadence_f[4].off2) {
1024 j->cadence_f[4].state = 4;
1025 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028 } else {
1029 j->cadence_f[4].state = 7;
1030 }
1031 } else {
1032 if (ixjdebug & 0x0008) {
1033 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035 j->cadence_f[4].on2);
1036 }
1037 j->cadence_f[4].state = 0;
1038 }
1039 } else if (j->cadence_f[4].state == 5) {
1040 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041 time_before(jiffies, j->cadence_f[4].on3max))) {
1042 if (j->cadence_f[4].off3) {
1043 j->cadence_f[4].state = 6;
1044 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 j->cadence_f[4].state = 0;
1052 }
1053 } else {
1054 if (ixjdebug & 0x0008) {
1055 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057 j->cadence_f[4].on3);
1058 }
1059 j->cadence_f[4].state = 0;
1060 }
1061 }
1062 if (ixjdebug & 0x0010) {
1063 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064 }
1065 if (ixjdebug & 0x0010) {
1066 switch(j->cadence_f[4].state) {
1067 case 1:
1068 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070 break;
1071 case 2:
1072 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074 break;
1075 case 3:
1076 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078 break;
1079 case 4:
1080 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082 break;
1083 case 5:
1084 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086 break;
1087 case 6:
1088 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090 break;
1091 }
1092 }
1093 }
1094 if (j->cadence_f[4].state == 7) {
1095 j->cadence_f[4].state = 0;
1096 j->pstn_ring_stop = jiffies;
1097 j->ex.bits.pstn_ring = 1;
1098 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099 if(ixjdebug & 0x0008) {
1100 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101 }
1102 }
1103 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105 if(ixjdebug & 0x0008) {
1106 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109 }
1110 j->pstn_ring_stop = j->pstn_ring_int = 0;
1111 daa_set_mode(j, SOP_PU_SLEEP);
1112 }
1113 outb_p(j->pld_scrw.byte, j->XILINXbase);
1114 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115 ixj_daa_cid_read(j);
1116 j->ex.bits.caller_id = 1;
1117 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118 j->pstn_cid_intr = 0;
1119 }
1120 if (daaint.bitreg.Cadence) {
1121 if(ixjdebug & 0x0008) {
1122 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123 }
1124 daa_set_mode(j, SOP_PU_SLEEP);
1125 j->ex.bits.pstn_ring = 0;
1126 }
1127 break;
1128 case SOP_PU_CONVERSATION:
1129 if (daaint.bitreg.VDD_OK) {
1130 if(!daaint.bitreg.SI_0) {
1131 if (!j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = jiffies;
1136 }
1137 } else {
1138 if (j->pstn_winkstart) {
1139 if(ixjdebug & 0x0008) {
1140 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141 }
1142 j->pstn_winkstart = 0;
1143 }
1144 }
1145 }
1146 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147 if(ixjdebug & 0x0008) {
1148 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149 }
1150 daa_set_mode(j, SOP_PU_SLEEP);
1151 j->pstn_winkstart = 0;
1152 j->ex.bits.pstn_wink = 1;
1153 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154 }
1155 break;
1156 }
1157 }
1158
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161 int board;
1162 unsigned long jifon;
1163 IXJ *j = (IXJ *)ptr;
1164 board = j->board;
1165
1166 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167 ixj_perfmon(j->timerchecks);
1168 j->hookstate = ixj_hookstate(j);
1169 if (j->tone_state) {
1170 if (!(j->hookstate)) {
1171 ixj_cpt_stop(j);
1172 if (j->m_hook) {
1173 j->m_hook = 0;
1174 j->ex.bits.hookstate = 1;
1175 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176 }
1177 clear_bit(board, &j->busyflags);
1178 ixj_add_timer(j);
1179 return;
1180 }
1181 if (j->tone_state == 1)
1182 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183 else
1184 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186 if (j->tone_state == 1) {
1187 ixj_play_tone(j, j->tone_index);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 } else {
1194 ixj_play_tone(j, 0);
1195 if (j->dsp.low == 0x20) {
1196 clear_bit(board, &j->busyflags);
1197 ixj_add_timer(j);
1198 return;
1199 }
1200 }
1201 } else {
1202 ixj_tone_timeout(j);
1203 if (j->flags.dialtone) {
1204 ixj_dialtone(j);
1205 }
1206 if (j->flags.busytone) {
1207 ixj_busytone(j);
1208 if (j->dsp.low == 0x20) {
1209 clear_bit(board, &j->busyflags);
1210 ixj_add_timer(j);
1211 return;
1212 }
1213 }
1214 if (j->flags.ringback) {
1215 ixj_ringback(j);
1216 if (j->dsp.low == 0x20) {
1217 clear_bit(board, &j->busyflags);
1218 ixj_add_timer(j);
1219 return;
1220 }
1221 }
1222 if (!j->tone_state) {
1223 ixj_cpt_stop(j);
1224 }
1225 }
1226 }
1227 if (!(j->tone_state && j->dsp.low == 0x20)) {
1228 if (IsRxReady(j)) {
1229 ixj_read_frame(j);
1230 }
1231 if (IsTxReady(j)) {
1232 ixj_write_frame(j);
1233 }
1234 }
1235 if (j->flags.cringing) {
1236 if (j->hookstate & 1) {
1237 j->flags.cringing = 0;
1238 ixj_ring_off(j);
1239 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240 switch(j->cadence_f[5].state) {
1241 case 0:
1242 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244 if(ixjdebug & 0x0004) {
1245 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246 }
1247 ixj_ring_on(j);
1248 }
1249 j->cadence_f[5].state = 1;
1250 break;
1251 case 1:
1252 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254 if(ixjdebug & 0x0004) {
1255 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256 }
1257 ixj_ring_off(j);
1258 j->cadence_f[5].state = 2;
1259 }
1260 break;
1261 case 2:
1262 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263 if(ixjdebug & 0x0004) {
1264 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265 }
1266 ixj_ring_on(j);
1267 if (j->cadence_f[5].on2) {
1268 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269 j->cadence_f[5].state = 3;
1270 } else {
1271 j->cadence_f[5].state = 7;
1272 }
1273 }
1274 break;
1275 case 3:
1276 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277 if(ixjdebug & 0x0004) {
1278 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279 }
1280 ixj_ring_off(j);
1281 if (j->cadence_f[5].off2) {
1282 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283 j->cadence_f[5].state = 4;
1284 } else {
1285 j->cadence_f[5].state = 7;
1286 }
1287 }
1288 break;
1289 case 4:
1290 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291 if(ixjdebug & 0x0004) {
1292 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293 }
1294 ixj_ring_on(j);
1295 if (j->cadence_f[5].on3) {
1296 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297 j->cadence_f[5].state = 5;
1298 } else {
1299 j->cadence_f[5].state = 7;
1300 }
1301 }
1302 break;
1303 case 5:
1304 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305 if(ixjdebug & 0x0004) {
1306 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307 }
1308 ixj_ring_off(j);
1309 if (j->cadence_f[5].off3) {
1310 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311 j->cadence_f[5].state = 6;
1312 } else {
1313 j->cadence_f[5].state = 7;
1314 }
1315 }
1316 break;
1317 case 6:
1318 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->cadence_f[5].state = 7;
1323 }
1324 break;
1325 case 7:
1326 if(ixjdebug & 0x0004) {
1327 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328 }
1329 j->flags.cidring = 1;
1330 j->cadence_f[5].state = 0;
1331 break;
1332 }
1333 if (j->flags.cidring && !j->flags.cidsent) {
1334 j->flags.cidsent = 1;
1335 if(j->fskdcnt) {
1336 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337 ixj_pre_cid(j);
1338 }
1339 j->flags.cidring = 0;
1340 }
1341 clear_bit(board, &j->busyflags);
1342 ixj_add_timer(j);
1343 return;
1344 } else {
1345 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346 if (j->flags.cidring && !j->flags.cidsent) {
1347 j->flags.cidsent = 1;
1348 if(j->fskdcnt) {
1349 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350 ixj_pre_cid(j);
1351 }
1352 j->flags.cidring = 0;
1353 }
1354 j->ring_cadence_t--;
1355 if (j->ring_cadence_t == -1)
1356 j->ring_cadence_t = 15;
1357 j->ring_cadence_jif = jiffies;
1358
1359 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361 j->flags.firstring = 1;
1362 else
1363 ixj_ring_on(j);
1364 } else {
1365 ixj_ring_off(j);
1366 if(!j->flags.cidsent)
1367 j->flags.cidring = 1;
1368 }
1369 }
1370 clear_bit(board, &j->busyflags);
1371 ixj_add_timer(j);
1372 return;
1373 }
1374 }
1375 if (!j->flags.ringing) {
1376 if (j->hookstate) { /* & 1) { */
1377 if (j->dsp.low != 0x20 &&
1378 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380 }
1381 LineMonitor(j);
1382 read_filters(j);
1383 ixj_WriteDSPCommand(0x511B, j);
1384 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385 if (!j->m_hook && (j->hookstate & 1)) {
1386 j->m_hook = j->ex.bits.hookstate = 1;
1387 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388 }
1389 } else {
1390 if (j->ex.bits.dtmf_ready) {
1391 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392 }
1393 if (j->m_hook) {
1394 j->m_hook = 0;
1395 j->ex.bits.hookstate = 1;
1396 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397 }
1398 }
1399 }
1400 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401 ixj_pstn_state(j);
1402 }
1403 if (j->ex.bytes) {
1404 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1405 }
1406 clear_bit(board, &j->busyflags);
1407 }
1408 ixj_add_timer(j);
1409 }
1410
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413 unsigned long jif;
1414
1415 jif = jiffies + ((60 * hertz) / 100);
1416 while (!IsStatusReady(j)) {
1417 ixj_perfmon(j->statuswait);
1418 if (time_after(jiffies, jif)) {
1419 ixj_perfmon(j->statuswaitfail);
1420 return -1;
1421 }
1422 }
1423 return 0;
1424 }
1425
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428 unsigned long jif;
1429
1430 jif = jiffies + ((60 * hertz) / 100);
1431 while (!IsPCControlReady(j)) {
1432 ixj_perfmon(j->pcontrolwait);
1433 if (time_after(jiffies, jif)) {
1434 ixj_perfmon(j->pcontrolwaitfail);
1435 return -1;
1436 }
1437 }
1438 return 0;
1439 }
1440
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443 BYTES bytes;
1444 unsigned long jif;
1445
1446 atomic_inc(&j->DSPWrite);
1447 if(atomic_read(&j->DSPWrite) > 1) {
1448 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449 return -1;
1450 }
1451 bytes.high = (cmd & 0xFF00) >> 8;
1452 bytes.low = cmd & 0x00FF;
1453 jif = jiffies + ((60 * hertz) / 100);
1454 while (!IsControlReady(j)) {
1455 ixj_perfmon(j->iscontrolready);
1456 if (time_after(jiffies, jif)) {
1457 ixj_perfmon(j->iscontrolreadyfail);
1458 atomic_dec(&j->DSPWrite);
1459 if(atomic_read(&j->DSPWrite) > 0) {
1460 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461 while(atomic_read(&j->DSPWrite) > 0) {
1462 atomic_dec(&j->DSPWrite);
1463 }
1464 }
1465 return -1;
1466 }
1467 }
1468 outb(bytes.low, j->DSPbase + 6);
1469 outb(bytes.high, j->DSPbase + 7);
1470
1471 if (ixj_status_wait(j)) {
1472 j->ssr.low = 0xFF;
1473 j->ssr.high = 0xFF;
1474 atomic_dec(&j->DSPWrite);
1475 if(atomic_read(&j->DSPWrite) > 0) {
1476 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477 while(atomic_read(&j->DSPWrite) > 0) {
1478 atomic_dec(&j->DSPWrite);
1479 }
1480 }
1481 return -1;
1482 }
1483 /* Read Software Status Register */
1484 j->ssr.low = inb_p(j->DSPbase + 2);
1485 j->ssr.high = inb_p(j->DSPbase + 3);
1486 atomic_dec(&j->DSPWrite);
1487 if(atomic_read(&j->DSPWrite) > 0) {
1488 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489 while(atomic_read(&j->DSPWrite) > 0) {
1490 atomic_dec(&j->DSPWrite);
1491 }
1492 }
1493 return 0;
1494 }
1495
1496 /***************************************************************************
1497 *
1498 * General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503 if (ixj_WriteDSPCommand(0x5143, j))
1504 return -1;
1505
1506 j->gpio.bytes.low = j->ssr.low;
1507 j->gpio.bytes.high = j->ssr.high;
1508
1509 return 0;
1510 }
1511
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514 if (j->cardtype == QTI_LINEJACK) {
1515 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520 outb(j->pld_scrw.byte, j->XILINXbase);
1521 }
1522 }
1523
1524 /*********************************************************************
1525 * GPIO Pins are configured as follows on the Quicknet Internet
1526 * PhoneJACK Telephony Cards
1527 *
1528 * POTS Select GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540 if (j->cardtype == QTI_PHONEJACK_LITE) {
1541 if (arg != PORT_POTS)
1542 return 10;
1543 else
1544 return 0;
1545 }
1546 switch (arg) {
1547 case PORT_POTS:
1548 j->port = PORT_POTS;
1549 switch (j->cardtype) {
1550 case QTI_PHONECARD:
1551 if (j->flags.pcmciasct == 1)
1552 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553 else
1554 return 11;
1555 break;
1556 case QTI_PHONEJACK_PCI:
1557 j->pld_slicw.pcib.mic = 0;
1558 j->pld_slicw.pcib.spk = 0;
1559 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560 break;
1561 case QTI_LINEJACK:
1562 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1563 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1564 Software Control Register */
1565 return 2;
1566 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1567
1568 outb(j->pld_scrw.byte, j->XILINXbase);
1569 j->pld_clock.byte = 0;
1570 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571 j->pld_slicw.bits.rly1 = 1;
1572 j->pld_slicw.bits.spken = 0;
1573 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1575 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1576 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1577 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1578 ixj_mixer(0x0E80, j); /*Mic mute */
1579 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1580 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1581 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1582 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584 break;
1585 case QTI_PHONEJACK:
1586 j->gpio.bytes.high = 0x0B;
1587 j->gpio.bits.gpio6 = 0;
1588 j->gpio.bits.gpio7 = 0;
1589 ixj_WriteDSPCommand(j->gpio.word, j);
1590 break;
1591 }
1592 break;
1593 case PORT_PSTN:
1594 if (j->cardtype == QTI_LINEJACK) {
1595 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597 j->pld_slicw.bits.rly3 = 0;
1598 j->pld_slicw.bits.rly1 = 1;
1599 j->pld_slicw.bits.spken = 0;
1600 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601 j->port = PORT_PSTN;
1602 } else {
1603 return 4;
1604 }
1605 break;
1606 case PORT_SPEAKER:
1607 j->port = PORT_SPEAKER;
1608 switch (j->cardtype) {
1609 case QTI_PHONECARD:
1610 if (j->flags.pcmciasct) {
1611 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612 }
1613 break;
1614 case QTI_PHONEJACK_PCI:
1615 j->pld_slicw.pcib.mic = 1;
1616 j->pld_slicw.pcib.spk = 1;
1617 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618 break;
1619 case QTI_LINEJACK:
1620 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1621 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1622 Software Control Register */
1623 return 2;
1624 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1625
1626 outb(j->pld_scrw.byte, j->XILINXbase);
1627 j->pld_clock.byte = 0;
1628 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629 j->pld_slicw.bits.rly1 = 1;
1630 j->pld_slicw.bits.spken = 1;
1631 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1633 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1634 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1635 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1636 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1637 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1638 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1639 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1640 break;
1641 case QTI_PHONEJACK:
1642 j->gpio.bytes.high = 0x0B;
1643 j->gpio.bits.gpio6 = 0;
1644 j->gpio.bits.gpio7 = 1;
1645 ixj_WriteDSPCommand(j->gpio.word, j);
1646 break;
1647 }
1648 break;
1649 case PORT_HANDSET:
1650 if (j->cardtype != QTI_PHONEJACK) {
1651 return 5;
1652 } else {
1653 j->gpio.bytes.high = 0x0B;
1654 j->gpio.bits.gpio6 = 1;
1655 j->gpio.bits.gpio7 = 0;
1656 ixj_WriteDSPCommand(j->gpio.word, j);
1657 j->port = PORT_HANDSET;
1658 }
1659 break;
1660 default:
1661 return 6;
1662 break;
1663 }
1664 return 0;
1665 }
1666
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669 if (j->cardtype == QTI_LINEJACK) {
1670 if (arg) {
1671 if (j->port == PORT_PSTN) {
1672 j->pld_slicw.bits.rly1 = 0;
1673 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674 j->flags.pots_pstn = 1;
1675 return 1;
1676 } else {
1677 j->flags.pots_pstn = 0;
1678 return 0;
1679 }
1680 } else {
1681 j->pld_slicw.bits.rly1 = 1;
1682 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683 j->flags.pots_pstn = 0;
1684 return 1;
1685 }
1686 } else {
1687 return 0;
1688 }
1689 }
1690
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694 {
1695 if (ixjdebug & 0x0004)
1696 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1697
1698 j->gpio.bytes.high = 0x0B;
1699 j->gpio.bytes.low = 0x00;
1700 j->gpio.bits.gpio1 = 1;
1701 j->gpio.bits.gpio2 = 1;
1702 j->gpio.bits.gpio5 = 0;
1703 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1704 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705 {
1706 if (ixjdebug & 0x0004)
1707 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710 }
1711 }
1712
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715 if(j->cardtype == QTI_PHONECARD){
1716 if(j->flags.pcmciascp){
1717 if(val == -1)
1718 return j->siadc.bits.rxg;
1719
1720 if(val < 0 || val > 0x1F)
1721 return -1;
1722
1723 j->siadc.bits.hom = 0; /* Handset Out Mute */
1724 j->siadc.bits.lom = 0; /* Line Out Mute */
1725 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1726 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1727 j->psccr.bits.rw = 0; /* Read / Write flag */
1728 j->psccr.bits.dev = 0;
1729 outb(j->siadc.byte, j->XILINXbase + 0x00);
1730 outb(j->psccr.byte, j->XILINXbase + 0x01);
1731 ixj_PCcontrol_wait(j);
1732 return j->siadc.bits.rxg;
1733 }
1734 }
1735 return -1;
1736 }
1737
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740 if(j->cardtype == QTI_PHONECARD){
1741 if(j->flags.pcmciascp){
1742 if(val == -1)
1743 return j->sidac.bits.txg;
1744
1745 if(val < 0 || val > 0x1F)
1746 return -1;
1747
1748 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1749 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1750 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1751 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1752 j->psccr.bits.rw = 0; /* Read / Write flag */
1753 j->psccr.bits.dev = 0;
1754 outb(j->sidac.byte, j->XILINXbase + 0x00);
1755 outb(j->psccr.byte, j->XILINXbase + 0x01);
1756 ixj_PCcontrol_wait(j);
1757 return j->sidac.bits.txg;
1758 }
1759 }
1760 return -1;
1761 }
1762
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766 if (!j->flags.pcmciastate) {
1767 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769 j->flags.pcmciastate = 4;
1770 return 0;
1771 }
1772 if (j->pccr1.bits.ed) {
1773 j->pccr1.bits.ed = 0;
1774 j->psccr.bits.dev = 3;
1775 j->psccr.bits.rw = 1;
1776 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777 ixj_PCcontrol_wait(j);
1778 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780 j->psccr.bits.dev = 3;
1781 j->psccr.bits.rw = 0;
1782 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783 ixj_PCcontrol_wait(j);
1784 return j->pslic.bits.led2 ? 1 : 0;
1785 } else if (j->flags.pcmciasct) {
1786 return j->r_hook;
1787 } else {
1788 return 1;
1789 }
1790 } else if (j->flags.pcmciastate == 4) {
1791 if (!j->pccr1.bits.drf) {
1792 j->flags.pcmciastate = 3;
1793 }
1794 return 0;
1795 } else if (j->flags.pcmciastate == 3) {
1796 j->pccr2.bits.pwr = 0;
1797 j->pccr2.bits.rstc = 1;
1798 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799 j->checkwait = jiffies + (hertz * 2);
1800 j->flags.incheck = 1;
1801 j->flags.pcmciastate = 2;
1802 return 0;
1803 } else if (j->flags.pcmciastate == 2) {
1804 if (j->flags.incheck) {
1805 if (time_before(jiffies, j->checkwait)) {
1806 return 0;
1807 } else {
1808 j->flags.incheck = 0;
1809 }
1810 }
1811 j->pccr2.bits.pwr = 0;
1812 j->pccr2.bits.rstc = 0;
1813 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814 j->flags.pcmciastate = 1;
1815 return 0;
1816 } else if (j->flags.pcmciastate == 1) {
1817 j->flags.pcmciastate = 0;
1818 if (!j->pccr1.bits.drf) {
1819 j->psccr.bits.dev = 3;
1820 j->psccr.bits.rw = 1;
1821 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822 ixj_PCcontrol_wait(j);
1823 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1824
1825 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1826
1827 if (j->flags.pcmciasct == 3) {
1828 j->flags.pcmciastate = 4;
1829 return 0;
1830 } else if (j->flags.pcmciasct == 0) {
1831 j->pccr2.bits.pwr = 1;
1832 j->pccr2.bits.rstc = 0;
1833 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834 j->port = PORT_SPEAKER;
1835 } else {
1836 j->port = PORT_POTS;
1837 }
1838 j->sic1.bits.cpd = 0; /* Chip Power Down */
1839 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1840 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1841 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1842 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1843 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1844 j->psccr.bits.rw = 0; /* Read / Write flag */
1845 j->psccr.bits.dev = 0;
1846 outb(j->sic1.byte, j->XILINXbase + 0x00);
1847 outb(j->psccr.byte, j->XILINXbase + 0x01);
1848 ixj_PCcontrol_wait(j);
1849
1850 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1851 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1852 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1853 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1854 j->sic2.bits.hpd = 0; /* HPF disable */
1855 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(j->sic2.byte, j->XILINXbase + 0x00);
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1870 j->psccr.bits.rw = 0; /* Read / Write flag */
1871 j->psccr.bits.dev = 0;
1872 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1873 outb(j->psccr.byte, j->XILINXbase + 0x01);
1874 ixj_PCcontrol_wait(j);
1875
1876 j->sirxg.bits.lig = 1; /* Line In Gain */
1877 j->sirxg.bits.lim = 1; /* Line In Mute */
1878 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1879 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1880 j->sirxg.bits.him = 0; /* Handset In Mute */
1881 j->sirxg.bits.iir = 1; /* IIR */
1882 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1883 j->psccr.bits.rw = 0; /* Read / Write flag */
1884 j->psccr.bits.dev = 0;
1885 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886 outb(j->psccr.byte, j->XILINXbase + 0x01);
1887 ixj_PCcontrol_wait(j);
1888
1889 ixj_siadc(j, 0x17);
1890 ixj_sidac(j, 0x1D);
1891
1892 j->siaatt.bits.sot = 0;
1893 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1894 j->psccr.bits.rw = 0; /* Read / Write flag */
1895 j->psccr.bits.dev = 0;
1896 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897 outb(j->psccr.byte, j->XILINXbase + 0x01);
1898 ixj_PCcontrol_wait(j);
1899
1900 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901 j->psccr.byte = j->pslic.byte = 0;
1902 j->pslic.bits.powerdown = 1;
1903 j->psccr.bits.dev = 3;
1904 j->psccr.bits.rw = 0;
1905 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906 ixj_PCcontrol_wait(j);
1907 }
1908 }
1909 return 0;
1910 } else {
1911 j->flags.pcmciascp = 0;
1912 return 0;
1913 }
1914 return 0;
1915 }
1916
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919 int fOffHook = 0;
1920
1921 switch (j->cardtype) {
1922 case QTI_PHONEJACK:
1923 ixj_gpio_read(j);
1924 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925 break;
1926 case QTI_LINEJACK:
1927 case QTI_PHONEJACK_LITE:
1928 case QTI_PHONEJACK_PCI:
1929 SLIC_GetState(j);
1930 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932 if(fOffHook != j->p_hook) {
1933 if(!j->checkwait) {
1934 j->checkwait = jiffies;
1935 }
1936 if(time_before(jiffies, j->checkwait + 2)) {
1937 fOffHook ^= 1;
1938 } else {
1939 j->checkwait = 0;
1940 }
1941 j->p_hook = fOffHook;
1942 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943 }
1944 } else {
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947 if (j->flags.ringing || j->flags.cringing) {
1948 if (!in_interrupt()) {
1949 msleep(20);
1950 }
1951 SLIC_GetState(j);
1952 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953 ixj_ring_on(j);
1954 }
1955 }
1956 if (j->cardtype == QTI_PHONEJACK_PCI) {
1957 j->pld_scrr.byte = inb_p(j->XILINXbase);
1958 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959 } else
1960 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961 }
1962 }
1963 break;
1964 case QTI_PHONECARD:
1965 fOffHook = ixj_pcmcia_cable_check(j);
1966 break;
1967 }
1968 if (j->r_hook != fOffHook) {
1969 j->r_hook = fOffHook;
1970 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971 j->ex.bits.hookstate = 1;
1972 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973 } else if (!fOffHook) {
1974 j->flash_end = jiffies + ((60 * hertz) / 100);
1975 }
1976 }
1977 if (fOffHook) {
1978 if(time_before(jiffies, j->flash_end)) {
1979 j->ex.bits.flash = 1;
1980 j->flash_end = 0;
1981 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982 }
1983 } else {
1984 if(time_before(jiffies, j->flash_end)) {
1985 fOffHook = 1;
1986 }
1987 }
1988
1989 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990 fOffHook |= 2;
1991
1992 if (j->port == PORT_SPEAKER) {
1993 if(j->cardtype == QTI_PHONECARD) {
1994 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995 fOffHook |= 2;
1996 }
1997 } else {
1998 fOffHook |= 2;
1999 }
2000 }
2001
2002 if (j->port == PORT_HANDSET)
2003 fOffHook |= 2;
2004
2005 return fOffHook;
2006 }
2007
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011 {
2012 if (ixjdebug & 0x0004)
2013 printk(KERN_INFO "IXJ Ring Off\n");
2014 j->gpio.bytes.high = 0x0B;
2015 j->gpio.bytes.low = 0x00;
2016 j->gpio.bits.gpio1 = 0;
2017 j->gpio.bits.gpio2 = 1;
2018 j->gpio.bits.gpio5 = 0;
2019 ixj_WriteDSPCommand(j->gpio.word, j);
2020 } else /* Internet LineJACK */
2021 {
2022 if (ixjdebug & 0x0004)
2023 printk(KERN_INFO "IXJ Ring Off\n");
2024
2025 if(!j->flags.cidplay)
2026 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028 SLIC_GetState(j);
2029 }
2030 }
2031
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034 j->flags.cringing = 1;
2035 if (ixjdebug & 0x0004)
2036 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037 if (ixj_hookstate(j) & 1) {
2038 if (j->port == PORT_POTS)
2039 ixj_ring_off(j);
2040 j->flags.cringing = 0;
2041 if (ixjdebug & 0x0004)
2042 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044 j->ring_cadence_jif = jiffies;
2045 j->flags.cidsent = j->flags.cidring = 0;
2046 j->cadence_f[5].state = 0;
2047 if(j->cadence_f[5].on1)
2048 ixj_ring_on(j);
2049 } else {
2050 j->ring_cadence_jif = jiffies;
2051 j->ring_cadence_t = 15;
2052 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053 ixj_ring_on(j);
2054 } else {
2055 ixj_ring_off(j);
2056 }
2057 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058 }
2059 }
2060
2061 static int ixj_ring(IXJ *j)
2062 {
2063 char cntr;
2064 unsigned long jif;
2065
2066 j->flags.ringing = 1;
2067 if (ixj_hookstate(j) & 1) {
2068 ixj_ring_off(j);
2069 j->flags.ringing = 0;
2070 return 1;
2071 }
2072 for (cntr = 0; cntr < j->maxrings; cntr++) {
2073 jif = jiffies + (1 * hertz);
2074 ixj_ring_on(j);
2075 while (time_before(jiffies, jif)) {
2076 if (ixj_hookstate(j) & 1) {
2077 ixj_ring_off(j);
2078 j->flags.ringing = 0;
2079 return 1;
2080 }
2081 schedule_timeout_interruptible(1);
2082 if (signal_pending(current))
2083 break;
2084 }
2085 jif = jiffies + (3 * hertz);
2086 ixj_ring_off(j);
2087 while (time_before(jiffies, jif)) {
2088 if (ixj_hookstate(j) & 1) {
2089 msleep(10);
2090 if (ixj_hookstate(j) & 1) {
2091 j->flags.ringing = 0;
2092 return 1;
2093 }
2094 }
2095 schedule_timeout_interruptible(1);
2096 if (signal_pending(current))
2097 break;
2098 }
2099 }
2100 ixj_ring_off(j);
2101 j->flags.ringing = 0;
2102 return 0;
2103 }
2104
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107 IXJ *j = get_ixj(p->board);
2108 file_p->private_data = j;
2109
2110 if (!j->DSPbase)
2111 return -ENODEV;
2112
2113 if (file_p->f_mode & FMODE_READ) {
2114 if(!j->readers) {
2115 j->readers++;
2116 } else {
2117 return -EBUSY;
2118 }
2119 }
2120
2121 if (file_p->f_mode & FMODE_WRITE) {
2122 if(!j->writers) {
2123 j->writers++;
2124 } else {
2125 if (file_p->f_mode & FMODE_READ){
2126 j->readers--;
2127 }
2128 return -EBUSY;
2129 }
2130 }
2131
2132 if (j->cardtype == QTI_PHONECARD) {
2133 j->pslic.bits.powerdown = 0;
2134 j->psccr.bits.dev = 3;
2135 j->psccr.bits.rw = 0;
2136 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137 ixj_PCcontrol_wait(j);
2138 }
2139
2140 j->flags.cidplay = 0;
2141 j->flags.cidcw_ack = 0;
2142
2143 if (ixjdebug & 0x0002)
2144 printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146 j->framesread = j->frameswritten = 0;
2147 return 0;
2148 }
2149
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152 IXJ_TONE ti;
2153 int cnt;
2154 IXJ *j = file_p->private_data;
2155 int board = j->p.board;
2156
2157 /*
2158 * Set up locks to ensure that only one process is talking to the DSP at a time.
2159 * This is necessary to keep the DSP from locking up.
2160 */
2161 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162 schedule_timeout_interruptible(1);
2163 if (ixjdebug & 0x0002)
2164 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166 if (j->cardtype == QTI_PHONECARD)
2167 ixj_set_port(j, PORT_SPEAKER);
2168 else
2169 ixj_set_port(j, PORT_POTS);
2170
2171 aec_stop(j);
2172 ixj_play_stop(j);
2173 ixj_record_stop(j);
2174 set_play_volume(j, 0x100);
2175 set_rec_volume(j, 0x100);
2176 ixj_ring_off(j);
2177
2178 /* Restore the tone table to default settings. */
2179 ti.tone_index = 10;
2180 ti.gain0 = 1;
2181 ti.freq0 = hz941;
2182 ti.gain1 = 0;
2183 ti.freq1 = hz1209;
2184 ixj_init_tone(j, &ti);
2185 ti.tone_index = 11;
2186 ti.gain0 = 1;
2187 ti.freq0 = hz941;
2188 ti.gain1 = 0;
2189 ti.freq1 = hz1336;
2190 ixj_init_tone(j, &ti);
2191 ti.tone_index = 12;
2192 ti.gain0 = 1;
2193 ti.freq0 = hz941;
2194 ti.gain1 = 0;
2195 ti.freq1 = hz1477;
2196 ixj_init_tone(j, &ti);
2197 ti.tone_index = 13;
2198 ti.gain0 = 1;
2199 ti.freq0 = hz800;
2200 ti.gain1 = 0;
2201 ti.freq1 = 0;
2202 ixj_init_tone(j, &ti);
2203 ti.tone_index = 14;
2204 ti.gain0 = 1;
2205 ti.freq0 = hz1000;
2206 ti.gain1 = 0;
2207 ti.freq1 = 0;
2208 ixj_init_tone(j, &ti);
2209 ti.tone_index = 15;
2210 ti.gain0 = 1;
2211 ti.freq0 = hz1250;
2212 ti.gain1 = 0;
2213 ti.freq1 = 0;
2214 ixj_init_tone(j, &ti);
2215 ti.tone_index = 16;
2216 ti.gain0 = 1;
2217 ti.freq0 = hz950;
2218 ti.gain1 = 0;
2219 ti.freq1 = 0;
2220 ixj_init_tone(j, &ti);
2221 ti.tone_index = 17;
2222 ti.gain0 = 1;
2223 ti.freq0 = hz1100;
2224 ti.gain1 = 0;
2225 ti.freq1 = 0;
2226 ixj_init_tone(j, &ti);
2227 ti.tone_index = 18;
2228 ti.gain0 = 1;
2229 ti.freq0 = hz1400;
2230 ti.gain1 = 0;
2231 ti.freq1 = 0;
2232 ixj_init_tone(j, &ti);
2233 ti.tone_index = 19;
2234 ti.gain0 = 1;
2235 ti.freq0 = hz1500;
2236 ti.gain1 = 0;
2237 ti.freq1 = 0;
2238 ixj_init_tone(j, &ti);
2239 ti.tone_index = 20;
2240 ti.gain0 = 1;
2241 ti.freq0 = hz1600;
2242 ti.gain1 = 0;
2243 ti.freq1 = 0;
2244 ixj_init_tone(j, &ti);
2245 ti.tone_index = 21;
2246 ti.gain0 = 1;
2247 ti.freq0 = hz1800;
2248 ti.gain1 = 0;
2249 ti.freq1 = 0;
2250 ixj_init_tone(j, &ti);
2251 ti.tone_index = 22;
2252 ti.gain0 = 1;
2253 ti.freq0 = hz2100;
2254 ti.gain1 = 0;
2255 ti.freq1 = 0;
2256 ixj_init_tone(j, &ti);
2257 ti.tone_index = 23;
2258 ti.gain0 = 1;
2259 ti.freq0 = hz1300;
2260 ti.gain1 = 0;
2261 ti.freq1 = 0;
2262 ixj_init_tone(j, &ti);
2263 ti.tone_index = 24;
2264 ti.gain0 = 1;
2265 ti.freq0 = hz2450;
2266 ti.gain1 = 0;
2267 ti.freq1 = 0;
2268 ixj_init_tone(j, &ti);
2269 ti.tone_index = 25;
2270 ti.gain0 = 1;
2271 ti.freq0 = hz350;
2272 ti.gain1 = 0;
2273 ti.freq1 = hz440;
2274 ixj_init_tone(j, &ti);
2275 ti.tone_index = 26;
2276 ti.gain0 = 1;
2277 ti.freq0 = hz440;
2278 ti.gain1 = 0;
2279 ti.freq1 = hz480;
2280 ixj_init_tone(j, &ti);
2281 ti.tone_index = 27;
2282 ti.gain0 = 1;
2283 ti.freq0 = hz480;
2284 ti.gain1 = 0;
2285 ti.freq1 = hz620;
2286 ixj_init_tone(j, &ti);
2287
2288 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2289
2290 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2291
2292 j->ex.bits.dtmf_ready = 0;
2293 j->dtmf_state = 0;
2294 j->dtmf_wp = j->dtmf_rp = 0;
2295 j->rec_mode = j->play_mode = -1;
2296 j->flags.ringing = 0;
2297 j->maxrings = MAXRINGS;
2298 j->ring_cadence = USA_RING_CADENCE;
2299 if(j->cadence_f[5].enable) {
2300 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301 }
2302 j->drybuffer = 0;
2303 j->winktime = 320;
2304 j->flags.dtmf_oob = 0;
2305 for (cnt = 0; cnt < 4; cnt++)
2306 j->cadence_f[cnt].enable = 0;
2307
2308 idle(j);
2309
2310 if(j->cardtype == QTI_PHONECARD) {
2311 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312 }
2313
2314 if (file_p->f_mode & FMODE_READ)
2315 j->readers--;
2316 if (file_p->f_mode & FMODE_WRITE)
2317 j->writers--;
2318
2319 if (j->read_buffer && !j->readers) {
2320 kfree(j->read_buffer);
2321 j->read_buffer = NULL;
2322 j->read_buffer_size = 0;
2323 }
2324 if (j->write_buffer && !j->writers) {
2325 kfree(j->write_buffer);
2326 j->write_buffer = NULL;
2327 j->write_buffer_size = 0;
2328 }
2329 j->rec_codec = j->play_codec = 0;
2330 j->rec_frame_size = j->play_frame_size = 0;
2331 j->flags.cidsent = j->flags.cidring = 0;
2332
2333 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334 ixj_set_port(j, PORT_PSTN);
2335 daa_set_mode(j, SOP_PU_SLEEP);
2336 ixj_set_pots(j, 1);
2337 }
2338 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340 /* Set up the default signals for events */
2341 for (cnt = 0; cnt < 35; cnt++)
2342 j->ixj_signals[cnt] = SIGIO;
2343
2344 /* Set the excetion signal enable flags */
2345 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346 j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347 j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349 file_p->private_data = NULL;
2350 clear_bit(board, &j->busyflags);
2351 return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356 unsigned short fc, cnt, trg;
2357 int var;
2358
2359 trg = 0;
2360 if (ixj_WriteDSPCommand(0x5144, j)) {
2361 if(ixjdebug & 0x0001) {
2362 printk(KERN_INFO "Read Frame Counter failed!\n");
2363 }
2364 return -1;
2365 }
2366 fc = j->ssr.high << 8 | j->ssr.low;
2367 if (fc == j->frame_count)
2368 return 1;
2369
2370 j->frame_count = fc;
2371
2372 if (j->dtmf_proc)
2373 return 1;
2374
2375 var = 10;
2376
2377 for (cnt = 0; cnt < 4; cnt++) {
2378 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381 }
2382 return -1;
2383 }
2384 if (ixj_WriteDSPCommand(0x515C, j)) {
2385 if(ixjdebug & 0x0001) {
2386 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387 }
2388 return -1;
2389 }
2390 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392 if (j->cadence_f[cnt].enable) {
2393 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394 if (j->cadence_f[cnt].state == 0) {
2395 j->cadence_f[cnt].state = 1;
2396 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399 } else if (j->cadence_f[cnt].state == 2 &&
2400 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402 if (j->cadence_f[cnt].on2) {
2403 j->cadence_f[cnt].state = 3;
2404 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407 } else {
2408 j->cadence_f[cnt].state = 7;
2409 }
2410 } else if (j->cadence_f[cnt].state == 4 &&
2411 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413 if (j->cadence_f[cnt].on3) {
2414 j->cadence_f[cnt].state = 5;
2415 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418 } else {
2419 j->cadence_f[cnt].state = 7;
2420 }
2421 } else {
2422 j->cadence_f[cnt].state = 0;
2423 }
2424 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425 if (j->cadence_f[cnt].state == 1) {
2426 if(!j->cadence_f[cnt].on1) {
2427 j->cadence_f[cnt].state = 7;
2428 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430 if(j->cadence_f[cnt].off1) {
2431 j->cadence_f[cnt].state = 2;
2432 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435 } else {
2436 j->cadence_f[cnt].state = 7;
2437 }
2438 } else {
2439 j->cadence_f[cnt].state = 0;
2440 }
2441 } else if (j->cadence_f[cnt].state == 3) {
2442 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444 if(j->cadence_f[cnt].off2) {
2445 j->cadence_f[cnt].state = 4;
2446 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449 } else {
2450 j->cadence_f[cnt].state = 7;
2451 }
2452 } else {
2453 j->cadence_f[cnt].state = 0;
2454 }
2455 } else if (j->cadence_f[cnt].state == 5) {
2456 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458 if(j->cadence_f[cnt].off3) {
2459 j->cadence_f[cnt].state = 6;
2460 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463 } else {
2464 j->cadence_f[cnt].state = 7;
2465 }
2466 } else {
2467 j->cadence_f[cnt].state = 0;
2468 }
2469 } else {
2470 j->cadence_f[cnt].state = 0;
2471 }
2472 } else {
2473 switch(j->cadence_f[cnt].state) {
2474 case 1:
2475 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476 !j->cadence_f[cnt].off1 &&
2477 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479 j->cadence_f[cnt].state = 7;
2480 }
2481 break;
2482 case 3:
2483 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484 !j->cadence_f[cnt].off2 &&
2485 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486 j->cadence_f[cnt].state = 7;
2487 }
2488 break;
2489 case 5:
2490 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491 !j->cadence_f[cnt].off3) {
2492 j->cadence_f[cnt].state = 7;
2493 }
2494 break;
2495 }
2496 }
2497
2498 if (ixjdebug & 0x0040) {
2499 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500 switch(j->cadence_f[cnt].state) {
2501 case 0:
2502 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503 break;
2504 case 1:
2505 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507 break;
2508 case 2:
2509 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510 j->cadence_f[cnt].off1max);
2511 break;
2512 case 3:
2513 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514 j->cadence_f[cnt].on2max);
2515 break;
2516 case 4:
2517 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518 j->cadence_f[cnt].off2max);
2519 break;
2520 case 5:
2521 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522 j->cadence_f[cnt].on3max);
2523 break;
2524 case 6:
2525 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526 j->cadence_f[cnt].off3max);
2527 break;
2528 }
2529 }
2530 }
2531 if (j->cadence_f[cnt].state == 7) {
2532 j->cadence_f[cnt].state = 0;
2533 if (j->cadence_f[cnt].enable == 1)
2534 j->cadence_f[cnt].enable = 0;
2535 switch (cnt) {
2536 case 0:
2537 if(ixjdebug & 0x0020) {
2538 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539 }
2540 j->ex.bits.fc0 = 1;
2541 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542 break;
2543 case 1:
2544 if(ixjdebug & 0x0020) {
2545 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546 }
2547 j->ex.bits.fc1 = 1;
2548 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549 break;
2550 case 2:
2551 if(ixjdebug & 0x0020) {
2552 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553 }
2554 j->ex.bits.fc2 = 1;
2555 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556 break;
2557 case 3:
2558 if(ixjdebug & 0x0020) {
2559 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560 }
2561 j->ex.bits.fc3 = 1;
2562 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563 break;
2564 }
2565 }
2566 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569 trg = 1;
2570 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571 trg = 0;
2572 }
2573 switch (cnt) {
2574 case 0:
2575 if(ixjdebug & 0x0020) {
2576 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577 }
2578 j->ex.bits.f0 = 1;
2579 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580 break;
2581 case 1:
2582 if(ixjdebug & 0x0020) {
2583 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584 }
2585 j->ex.bits.f1 = 1;
2586 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587 break;
2588 case 2:
2589 if(ixjdebug & 0x0020) {
2590 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591 }
2592 j->ex.bits.f2 = 1;
2593 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594 break;
2595 case 3:
2596 if(ixjdebug & 0x0020) {
2597 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598 }
2599 j->ex.bits.f3 = 1;
2600 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601 break;
2602 }
2603 }
2604 }
2605 return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610 if (j->dtmf_proc) {
2611 return -1;
2612 }
2613 j->dtmf_proc = 1;
2614
2615 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2616 return -1;
2617
2618 j->dtmf.bytes.high = j->ssr.high;
2619 j->dtmf.bytes.low = j->ssr.low;
2620 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621 j->dtmf_state = 1;
2622 j->dtmf_current = j->dtmf.bits.digit;
2623 }
2624 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2625 {
2626 if(!j->cidcw_wait) {
2627 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628 j->dtmf_wp++;
2629 if (j->dtmf_wp == 79)
2630 j->dtmf_wp = 0;
2631 j->ex.bits.dtmf_ready = 1;
2632 if(j->ex_sig.bits.dtmf_ready) {
2633 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634 }
2635 }
2636 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637 if(ixjdebug & 0x0020) {
2638 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639 }
2640 j->flags.cidcw_ack = 1;
2641 }
2642 j->dtmf_state = 0;
2643 }
2644 j->dtmf_proc = 0;
2645
2646 return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657 static unsigned char table_ulaw2alaw[] =
2658 {
2659 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691 };
2692
2693 while (len--)
2694 {
2695 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696 buff++;
2697 }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702 static unsigned char table_alaw2ulaw[] =
2703 {
2704 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736 };
2737
2738 while (len--)
2739 {
2740 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741 buff++;
2742 }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747 unsigned long i = *ppos;
2748 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750 DECLARE_WAITQUEUE(wait, current);
2751
2752 if (j->flags.inread)
2753 return -EALREADY;
2754
2755 j->flags.inread = 1;
2756
2757 add_wait_queue(&j->read_q, &wait);
2758 set_current_state(TASK_INTERRUPTIBLE);
2759 mb();
2760
2761 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762 ++j->read_wait;
2763 if (file_p->f_flags & O_NONBLOCK) {
2764 set_current_state(TASK_RUNNING);
2765 remove_wait_queue(&j->read_q, &wait);
2766 j->flags.inread = 0;
2767 return -EAGAIN;
2768 }
2769 if (!ixj_hookstate(j)) {
2770 set_current_state(TASK_RUNNING);
2771 remove_wait_queue(&j->read_q, &wait);
2772 j->flags.inread = 0;
2773 return 0;
2774 }
2775 interruptible_sleep_on(&j->read_q);
2776 if (signal_pending(current)) {
2777 set_current_state(TASK_RUNNING);
2778 remove_wait_queue(&j->read_q, &wait);
2779 j->flags.inread = 0;
2780 return -EINTR;
2781 }
2782 }
2783
2784 remove_wait_queue(&j->read_q, &wait);
2785 set_current_state(TASK_RUNNING);
2786 /* Don't ever copy more than the user asks */
2787 if(j->rec_codec == ALAW)
2788 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790 j->read_buffer_ready = 0;
2791 if (i) {
2792 j->flags.inread = 0;
2793 return -EFAULT;
2794 } else {
2795 j->flags.inread = 0;
2796 return min(length, j->read_buffer_size);
2797 }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801 loff_t * ppos)
2802 {
2803 int pre_retval;
2804 ssize_t read_retval = 0;
2805 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807 pre_retval = ixj_PreRead(j, 0L);
2808 switch (pre_retval) {
2809 case NORMAL:
2810 read_retval = ixj_read(file_p, buf, length, ppos);
2811 ixj_PostRead(j, 0L);
2812 break;
2813 case NOPOST:
2814 read_retval = ixj_read(file_p, buf, length, ppos);
2815 break;
2816 case POSTONLY:
2817 ixj_PostRead(j, 0L);
2818 break;
2819 default:
2820 read_retval = pre_retval;
2821 }
2822 return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827 unsigned long i = *ppos;
2828 IXJ *j = file_p->private_data;
2829
2830 DECLARE_WAITQUEUE(wait, current);
2831
2832 if (j->flags.inwrite)
2833 return -EALREADY;
2834
2835 j->flags.inwrite = 1;
2836
2837 add_wait_queue(&j->write_q, &wait);
2838 set_current_state(TASK_INTERRUPTIBLE);
2839 mb();
2840
2841
2842 while (!j->write_buffers_empty) {
2843 ++j->write_wait;
2844 if (file_p->f_flags & O_NONBLOCK) {
2845 set_current_state(TASK_RUNNING);
2846 remove_wait_queue(&j->write_q, &wait);
2847 j->flags.inwrite = 0;
2848 return -EAGAIN;
2849 }
2850 if (!ixj_hookstate(j)) {
2851 set_current_state(TASK_RUNNING);
2852 remove_wait_queue(&j->write_q, &wait);
2853 j->flags.inwrite = 0;
2854 return 0;
2855 }
2856 interruptible_sleep_on(&j->write_q);
2857 if (signal_pending(current)) {
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 j->flags.inwrite = 0;
2861 return -EINTR;
2862 }
2863 }
2864 set_current_state(TASK_RUNNING);
2865 remove_wait_queue(&j->write_q, &wait);
2866 if (j->write_buffer_wp + count >= j->write_buffer_end)
2867 j->write_buffer_wp = j->write_buffer;
2868 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869 if (i) {
2870 j->flags.inwrite = 0;
2871 return -EFAULT;
2872 }
2873 if(j->play_codec == ALAW)
2874 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875 j->flags.inwrite = 0;
2876 return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881 int pre_retval;
2882 ssize_t write_retval = 0;
2883
2884 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886 pre_retval = ixj_PreWrite(j, 0L);
2887 switch (pre_retval) {
2888 case NORMAL:
2889 write_retval = ixj_write(file_p, buf, count, ppos);
2890 if (write_retval > 0) {
2891 ixj_PostWrite(j, 0L);
2892 j->write_buffer_wp += write_retval;
2893 j->write_buffers_empty--;
2894 }
2895 break;
2896 case NOPOST:
2897 write_retval = ixj_write(file_p, buf, count, ppos);
2898 if (write_retval > 0) {
2899 j->write_buffer_wp += write_retval;
2900 j->write_buffers_empty--;
2901 }
2902 break;
2903 case POSTONLY:
2904 ixj_PostWrite(j, 0L);
2905 break;
2906 default:
2907 write_retval = pre_retval;
2908 }
2909 return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914 int cnt, dly;
2915
2916 if (j->read_buffer) {
2917 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918 if (!(cnt % 16) && !IsRxReady(j)) {
2919 dly = 0;
2920 while (!IsRxReady(j)) {
2921 if (dly++ > 5) {
2922 dly = 0;
2923 break;
2924 }
2925 udelay(10);
2926 }
2927 }
2928 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930 inb_p(j->DSPbase + 0x0E);
2931 inb_p(j->DSPbase + 0x0F);
2932 }
2933 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935 }
2936 ++j->framesread;
2937 if (j->intercom != -1) {
2938 if (IsTxReady(get_ixj(j->intercom))) {
2939 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940 if (!(cnt % 16) && !IsTxReady(j)) {
2941 dly = 0;
2942 while (!IsTxReady(j)) {
2943 if (dly++ > 5) {
2944 dly = 0;
2945 break;
2946 }
2947 udelay(10);
2948 }
2949 }
2950 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952 }
2953 get_ixj(j->intercom)->frameswritten++;
2954 }
2955 } else {
2956 j->read_buffer_ready = 1;
2957 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2958
2959 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2960
2961 if(j->ixj_signals[SIG_READ_READY])
2962 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963 }
2964 }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969 {
2970 {
2971 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973 },
2974 {
2975 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977 },
2978 {
2979 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981 },
2982 {
2983 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985 },
2986 {
2987 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989 },
2990 {
2991 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993 }
2994 },
2995 {
2996 {
2997 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999 },
3000 {
3001 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003 },
3004 {
3005 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007 },
3008 {
3009 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011 },
3012 {
3013 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015 },
3016 {
3017 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019 }
3020 }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026 while (j->fskcnt < 20) {
3027 if(j->fskdcnt < (j->fsksize - 1))
3028 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030 j->fskcnt += 3;
3031 }
3032 j->fskcnt %= 20;
3033
3034 if (!bit)
3035 j->fskz++;
3036 if (j->fskz >= 6)
3037 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043 IXJ_CBYTE cb;
3044
3045 cb.cbyte = byte;
3046 ixj_write_cid_bit(j, 0);
3047 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060 int cnt;
3061
3062 for (cnt = 0; cnt < 150; cnt++) {
3063 ixj_write_cid_bit(j, 0);
3064 ixj_write_cid_bit(j, 1);
3065 }
3066 for (cnt = 0; cnt < 180; cnt++) {
3067 ixj_write_cid_bit(j, 1);
3068 }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073 int cnt;
3074
3075 for (cnt = 0; cnt < 80; cnt++) {
3076 ixj_write_cid_bit(j, 1);
3077 }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082 int cnt;
3083
3084 for (cnt = 0; cnt < strlen(s); cnt++) {
3085 ixj_write_cid_byte(j, s[cnt]);
3086 checksum = (checksum + s[cnt]);
3087 }
3088 return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093 int cnt;
3094
3095 for (cnt = 0; cnt < pad; cnt++) {
3096 if(j->fskdcnt < (j->fsksize - 1))
3097 j->fskdata[j->fskdcnt++] = 0x0000;
3098 }
3099 for (cnt = 0; cnt < 720; cnt++) {
3100 if(j->fskdcnt < (j->fsksize - 1))
3101 j->fskdata[j->fskdcnt++] = 0x0000;
3102 }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107 j->cid_play_codec = j->play_codec;
3108 j->cid_play_frame_size = j->play_frame_size;
3109 j->cid_play_volume = get_play_volume(j);
3110 j->cid_play_flag = j->flags.playing;
3111
3112 j->cid_rec_codec = j->rec_codec;
3113 j->cid_rec_volume = get_rec_volume(j);
3114 j->cid_rec_flag = j->flags.recording;
3115
3116 j->cid_play_aec_level = j->aec_level;
3117
3118 switch(j->baseframe.low) {
3119 case 0xA0:
3120 j->cid_base_frame_size = 20;
3121 break;
3122 case 0x50:
3123 j->cid_base_frame_size = 10;
3124 break;
3125 case 0xF0:
3126 j->cid_base_frame_size = 30;
3127 break;
3128 }
3129
3130 ixj_play_stop(j);
3131 ixj_cpt_stop(j);
3132
3133 j->flags.cidplay = 1;
3134
3135 set_base_frame(j, 30);
3136 set_play_codec(j, LINEAR16);
3137 set_play_volume(j, 0x1B);
3138 ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143 ixj_play_stop(j);
3144
3145 if(j->cidsize > 5000) {
3146 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147 }
3148 j->flags.cidplay = 0;
3149 if(ixjdebug & 0x0200) {
3150 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151 }
3152
3153 ixj_fsk_free(j);
3154
3155 j->fskdcnt = 0;
3156 set_base_frame(j, j->cid_base_frame_size);
3157 set_play_codec(j, j->cid_play_codec);
3158 ixj_aec_start(j, j->cid_play_aec_level);
3159 set_play_volume(j, j->cid_play_volume);
3160
3161 set_rec_codec(j, j->cid_rec_codec);
3162 set_rec_volume(j, j->cid_rec_volume);
3163
3164 if(j->cid_rec_flag)
3165 ixj_record_start(j);
3166
3167 if(j->cid_play_flag)
3168 ixj_play_start(j);
3169
3170 if(j->cid_play_flag) {
3171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3172 }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177 char sdmf1[50];
3178 char sdmf2[50];
3179 char sdmf3[80];
3180 char mdmflen, len1, len2, len3;
3181 int pad;
3182
3183 int checksum = 0;
3184
3185 if (j->dsp.low == 0x20 || j->flags.cidplay)
3186 return;
3187
3188 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189 j->cidsize = j->cidcnt = 0;
3190
3191 ixj_fsk_alloc(j);
3192
3193 strcpy(sdmf1, j->cid_send.month);
3194 strcat(sdmf1, j->cid_send.day);
3195 strcat(sdmf1, j->cid_send.hour);
3196 strcat(sdmf1, j->cid_send.min);
3197 strcpy(sdmf2, j->cid_send.number);
3198 strcpy(sdmf3, j->cid_send.name);
3199
3200 len1 = strlen(sdmf1);
3201 len2 = strlen(sdmf2);
3202 len3 = strlen(sdmf3);
3203 mdmflen = len1 + len2 + len3 + 6;
3204
3205 while(1){
3206 ixj_write_cid_seize(j);
3207
3208 ixj_write_cid_byte(j, 0x80);
3209 checksum = 0x80;
3210 ixj_write_cid_byte(j, mdmflen);
3211 checksum = checksum + mdmflen;
3212
3213 ixj_write_cid_byte(j, 0x01);
3214 checksum = checksum + 0x01;
3215 ixj_write_cid_byte(j, len1);
3216 checksum = checksum + len1;
3217 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218 if(ixj_hookstate(j) & 1)
3219 break;
3220
3221 ixj_write_cid_byte(j, 0x02);
3222 checksum = checksum + 0x02;
3223 ixj_write_cid_byte(j, len2);
3224 checksum = checksum + len2;
3225 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226 if(ixj_hookstate(j) & 1)
3227 break;
3228
3229 ixj_write_cid_byte(j, 0x07);
3230 checksum = checksum + 0x07;
3231 ixj_write_cid_byte(j, len3);
3232 checksum = checksum + len3;
3233 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234 if(ixj_hookstate(j) & 1)
3235 break;
3236
3237 checksum %= 256;
3238 checksum ^= 0xFF;
3239 checksum += 1;
3240
3241 ixj_write_cid_byte(j, (char) checksum);
3242
3243 pad = j->fskdcnt % 240;
3244 if (pad) {
3245 pad = 240 - pad;
3246 }
3247 ixj_pad_fsk(j, pad);
3248 break;
3249 }
3250
3251 ixj_write_frame(j);
3252 }
3253
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256 IXJ_TONE ti;
3257
3258 char sdmf1[50];
3259 char sdmf2[50];
3260 char sdmf3[80];
3261 char mdmflen, len1, len2, len3;
3262 int pad;
3263
3264 int checksum = 0;
3265
3266 if (j->dsp.low == 0x20 || j->flags.cidplay)
3267 return;
3268
3269 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270 j->cidsize = j->cidcnt = 0;
3271
3272 ixj_fsk_alloc(j);
3273
3274 j->flags.cidcw_ack = 0;
3275
3276 ti.tone_index = 23;
3277 ti.gain0 = 1;
3278 ti.freq0 = hz440;
3279 ti.gain1 = 0;
3280 ti.freq1 = 0;
3281 ixj_init_tone(j, &ti);
3282
3283 ixj_set_tone_on(1500, j);
3284 ixj_set_tone_off(32, j);
3285 if(ixjdebug & 0x0200) {
3286 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287 }
3288 ixj_play_tone(j, 23);
3289
3290 clear_bit(j->board, &j->busyflags);
3291 while(j->tone_state)
3292 schedule_timeout_interruptible(1);
3293 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294 schedule_timeout_interruptible(1);
3295 if(ixjdebug & 0x0200) {
3296 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297 }
3298
3299 ti.tone_index = 24;
3300 ti.gain0 = 1;
3301 ti.freq0 = hz2130;
3302 ti.gain1 = 0;
3303 ti.freq1 = hz2750;
3304 ixj_init_tone(j, &ti);
3305
3306 ixj_set_tone_off(10, j);
3307 ixj_set_tone_on(600, j);
3308 if(ixjdebug & 0x0200) {
3309 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310 }
3311 ixj_play_tone(j, 24);
3312
3313 clear_bit(j->board, &j->busyflags);
3314 while(j->tone_state)
3315 schedule_timeout_interruptible(1);
3316 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317 schedule_timeout_interruptible(1);
3318 if(ixjdebug & 0x0200) {
3319 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320 }
3321
3322 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324 clear_bit(j->board, &j->busyflags);
3325 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326 schedule_timeout_interruptible(1);
3327 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328 schedule_timeout_interruptible(1);
3329 j->cidcw_wait = 0;
3330 if(!j->flags.cidcw_ack) {
3331 if(ixjdebug & 0x0200) {
3332 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333 }
3334 ixj_post_cid(j);
3335 if(j->cid_play_flag) {
3336 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3337 }
3338 return;
3339 } else {
3340 ixj_pre_cid(j);
3341 }
3342 j->flags.cidcw_ack = 0;
3343 strcpy(sdmf1, j->cid_send.month);
3344 strcat(sdmf1, j->cid_send.day);
3345 strcat(sdmf1, j->cid_send.hour);
3346 strcat(sdmf1, j->cid_send.min);
3347 strcpy(sdmf2, j->cid_send.number);
3348 strcpy(sdmf3, j->cid_send.name);
3349
3350 len1 = strlen(sdmf1);
3351 len2 = strlen(sdmf2);
3352 len3 = strlen(sdmf3);
3353 mdmflen = len1 + len2 + len3 + 6;
3354
3355 ixj_write_cidcw_seize(j);
3356
3357 ixj_write_cid_byte(j, 0x80);
3358 checksum = 0x80;
3359 ixj_write_cid_byte(j, mdmflen);
3360 checksum = checksum + mdmflen;
3361
3362 ixj_write_cid_byte(j, 0x01);
3363 checksum = checksum + 0x01;
3364 ixj_write_cid_byte(j, len1);
3365 checksum = checksum + len1;
3366 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368 ixj_write_cid_byte(j, 0x02);
3369 checksum = checksum + 0x02;
3370 ixj_write_cid_byte(j, len2);
3371 checksum = checksum + len2;
3372 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374 ixj_write_cid_byte(j, 0x07);
3375 checksum = checksum + 0x07;
3376 ixj_write_cid_byte(j, len3);
3377 checksum = checksum + len3;
3378 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380 checksum %= 256;
3381 checksum ^= 0xFF;
3382 checksum += 1;
3383
3384 ixj_write_cid_byte(j, (char) checksum);
3385
3386 pad = j->fskdcnt % 240;
3387 if (pad) {
3388 pad = 240 - pad;
3389 }
3390 ixj_pad_fsk(j, pad);
3391 if(ixjdebug & 0x0200) {
3392 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393 }
3394 }
3395
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398 char mdmflen;
3399 int pad;
3400
3401 int checksum = 0;
3402
3403 if (j->dsp.low == 0x20 || j->flags.cidplay)
3404 return;
3405
3406 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407 j->cidsize = j->cidcnt = 0;
3408
3409 ixj_fsk_alloc(j);
3410
3411 mdmflen = 3;
3412
3413 if (j->port == PORT_POTS)
3414 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416 ixj_write_cid_seize(j);
3417
3418 ixj_write_cid_byte(j, 0x82);
3419 checksum = 0x82;
3420 ixj_write_cid_byte(j, mdmflen);
3421 checksum = checksum + mdmflen;
3422
3423 ixj_write_cid_byte(j, 0x0B);
3424 checksum = checksum + 0x0B;
3425 ixj_write_cid_byte(j, 1);
3426 checksum = checksum + 1;
3427
3428 if(msg) {
3429 ixj_write_cid_byte(j, 0xFF);
3430 checksum = checksum + 0xFF;
3431 }
3432 else {
3433 ixj_write_cid_byte(j, 0x00);
3434 checksum = checksum + 0x00;
3435 }
3436
3437 checksum %= 256;
3438 checksum ^= 0xFF;
3439 checksum += 1;
3440
3441 ixj_write_cid_byte(j, (char) checksum);
3442
3443 pad = j->fskdcnt % 240;
3444 if (pad) {
3445 pad = 240 - pad;
3446 }
3447 ixj_pad_fsk(j, pad);
3448 }
3449
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452 int cnt, frame_count, dly;
3453 IXJ_WORD dat;
3454
3455 frame_count = 0;
3456 if(j->flags.cidplay) {
3457 for(cnt = 0; cnt < 480; cnt++) {
3458 if (!(cnt % 16) && !IsTxReady(j)) {
3459 dly = 0;
3460 while (!IsTxReady(j)) {
3461 if (dly++ > 5) {
3462 dly = 0;
3463 break;
3464 }
3465 udelay(10);
3466 }
3467 }
3468 dat.word = j->fskdata[j->cidcnt++];
3469 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471 cnt++;
3472 }
3473 if(j->cidcnt >= j->fskdcnt) {
3474 ixj_post_cid(j);
3475 }
3476 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477 and there is real audio data in the buffer, we need to throw it away because
3478 we just used it's time slot */
3479 if (j->write_buffer_rp > j->write_buffer_wp) {
3480 j->write_buffer_rp += j->cid_play_frame_size * 2;
3481 if (j->write_buffer_rp >= j->write_buffer_end) {
3482 j->write_buffer_rp = j->write_buffer;
3483 }
3484 j->write_buffers_empty++;
3485 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3486
3487 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3488 }
3489 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490 if (j->write_buffer_wp > j->write_buffer_rp) {
3491 frame_count =
3492 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493 }
3494 if (j->write_buffer_rp > j->write_buffer_wp) {
3495 frame_count =
3496 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498 }
3499 if (frame_count >= 1) {
3500 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501 BYTES blankword;
3502
3503 switch (j->play_mode) {
3504 case PLAYBACK_MODE_ULAW:
3505 case PLAYBACK_MODE_ALAW:
3506 blankword.low = blankword.high = 0xFF;
3507 break;
3508 case PLAYBACK_MODE_8LINEAR:
3509 case PLAYBACK_MODE_16LINEAR:
3510 default:
3511 blankword.low = blankword.high = 0x00;
3512 break;
3513 case PLAYBACK_MODE_8LINEAR_WSS:
3514 blankword.low = blankword.high = 0x80;
3515 break;
3516 }
3517 for (cnt = 0; cnt < 16; cnt++) {
3518 if (!(cnt % 16) && !IsTxReady(j)) {
3519 dly = 0;
3520 while (!IsTxReady(j)) {
3521 if (dly++ > 5) {
3522 dly = 0;
3523 break;
3524 }
3525 udelay(10);
3526 }
3527 }
3528 outb_p((blankword.low), j->DSPbase + 0x0C);
3529 outb_p((blankword.high), j->DSPbase + 0x0D);
3530 }
3531 j->flags.play_first_frame = 0;
3532 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533 for (cnt = 0; cnt < 24; cnt++) {
3534 BYTES blankword;
3535
3536 if(cnt == 12) {
3537 blankword.low = 0x02;
3538 blankword.high = 0x00;
3539 }
3540 else {
3541 blankword.low = blankword.high = 0x00;
3542 }
3543 if (!(cnt % 16) && !IsTxReady(j)) {
3544 dly = 0;
3545 while (!IsTxReady(j)) {
3546 if (dly++ > 5) {
3547 dly = 0;
3548 break;
3549 }
3550 udelay(10);
3551 }
3552 }
3553 outb_p((blankword.low), j->DSPbase + 0x0C);
3554 outb_p((blankword.high), j->DSPbase + 0x0D);
3555 }
3556 j->flags.play_first_frame = 0;
3557 }
3558 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559 if (!(cnt % 16) && !IsTxReady(j)) {
3560 dly = 0;
3561 while (!IsTxReady(j)) {
3562 if (dly++ > 5) {
3563 dly = 0;
3564 break;
3565 }
3566 udelay(10);
3567 }
3568 }
3569 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3570 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571 if (j->write_buffer_rp[cnt] == 0 &&
3572 j->write_buffer_rp[cnt + 1] == 0 &&
3573 j->write_buffer_rp[cnt + 2] == 0 &&
3574 j->write_buffer_rp[cnt + 3] == 0 &&
3575 j->write_buffer_rp[cnt + 4] == 0 &&
3576 j->write_buffer_rp[cnt + 5] == 0 &&
3577 j->write_buffer_rp[cnt + 6] == 0 &&
3578 j->write_buffer_rp[cnt + 7] == 0 &&
3579 j->write_buffer_rp[cnt + 8] == 0 &&
3580 j->write_buffer_rp[cnt + 9] == 0) {
3581 /* someone is trying to write silence lets make this a type 0 frame. */
3582 outb_p(0x00, j->DSPbase + 0x0C);
3583 outb_p(0x00, j->DSPbase + 0x0D);
3584 } else {
3585 /* so all other frames are type 1. */
3586 outb_p(0x01, j->DSPbase + 0x0C);
3587 outb_p(0x00, j->DSPbase + 0x0D);
3588 }
3589 }
3590 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592 *(j->write_buffer_rp + cnt) = 0;
3593 *(j->write_buffer_rp + cnt + 1) = 0;
3594 }
3595 j->write_buffer_rp += j->play_frame_size * 2;
3596 if (j->write_buffer_rp >= j->write_buffer_end) {
3597 j->write_buffer_rp = j->write_buffer;
3598 }
3599 j->write_buffers_empty++;
3600 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3601
3602 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3603
3604 ++j->frameswritten;
3605 }
3606 } else {
3607 j->drybuffer++;
3608 }
3609 if(j->ixj_signals[SIG_WRITE_READY]) {
3610 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611 }
3612 }
3613
3614 static int idle(IXJ *j)
3615 {
3616 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3617
3618 return 0;
3619
3620 if (j->ssr.high || j->ssr.low) {
3621 return 0;
3622 } else {
3623 j->play_mode = -1;
3624 j->flags.playing = 0;
3625 j->rec_mode = -1;
3626 j->flags.recording = 0;
3627 return 1;
3628 }
3629 }
3630
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633 unsigned short cmd;
3634 int cnt;
3635
3636 idle(j);
3637 j->cid_play_aec_level = j->aec_level;
3638 aec_stop(j);
3639 for (cnt = 0; cnt < 10; cnt++) {
3640 if (idle(j))
3641 break;
3642 }
3643 if (j->ssr.high || j->ssr.low)
3644 return -1;
3645 if (j->dsp.low != 0x20) {
3646 switch (size) {
3647 case 30:
3648 cmd = 0x07F0;
3649 /* Set Base Frame Size to 240 pg9-10 8021 */
3650 break;
3651 case 20:
3652 cmd = 0x07A0;
3653 /* Set Base Frame Size to 160 pg9-10 8021 */
3654 break;
3655 case 10:
3656 cmd = 0x0750;
3657 /* Set Base Frame Size to 80 pg9-10 8021 */
3658 break;
3659 default:
3660 return -1;
3661 }
3662 } else {
3663 if (size == 30)
3664 return size;
3665 else
3666 return -1;
3667 }
3668 if (ixj_WriteDSPCommand(cmd, j)) {
3669 j->baseframe.high = j->baseframe.low = 0xFF;
3670 return -1;
3671 } else {
3672 j->baseframe.high = j->ssr.high;
3673 j->baseframe.low = j->ssr.low;
3674 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676 return -1;
3677 }
3678 }
3679 ixj_aec_start(j, j->cid_play_aec_level);
3680 return size;
3681 }
3682
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685 int retval = 0;
3686
3687 j->rec_codec = rate;
3688
3689 switch (rate) {
3690 case G723_63:
3691 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692 j->rec_frame_size = 12;
3693 j->rec_mode = 0;
3694 } else {
3695 retval = 1;
3696 }
3697 break;
3698 case G723_53:
3699 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700 j->rec_frame_size = 10;
3701 j->rec_mode = 0;
3702 } else {
3703 retval = 1;
3704 }
3705 break;
3706 case TS85:
3707 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708 j->rec_frame_size = 16;
3709 j->rec_mode = 0;
3710 } else {
3711 retval = 1;
3712 }
3713 break;
3714 case TS48:
3715 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716 j->rec_frame_size = 9;
3717 j->rec_mode = 0;
3718 } else {
3719 retval = 1;
3720 }
3721 break;
3722 case TS41:
3723 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724 j->rec_frame_size = 8;
3725 j->rec_mode = 0;
3726 } else {
3727 retval = 1;
3728 }
3729 break;
3730 case G728:
3731 if (j->dsp.low != 0x20) {
3732 j->rec_frame_size = 48;
3733 j->rec_mode = 0;
3734 } else {
3735 retval = 1;
3736 }
3737 break;
3738 case G729:
3739 if (j->dsp.low != 0x20) {
3740 if (!j->flags.g729_loaded) {
3741 retval = 1;
3742 break;
3743 }
3744 switch (j->baseframe.low) {
3745 case 0xA0:
3746 j->rec_frame_size = 10;
3747 break;
3748 case 0x50:
3749 j->rec_frame_size = 5;
3750 break;
3751 default:
3752 j->rec_frame_size = 15;
3753 break;
3754 }
3755 j->rec_mode = 0;
3756 } else {
3757 retval = 1;
3758 }
3759 break;
3760 case G729B:
3761 if (j->dsp.low != 0x20) {
3762 if (!j->flags.g729_loaded) {
3763 retval = 1;
3764 break;
3765 }
3766 switch (j->baseframe.low) {
3767 case 0xA0:
3768 j->rec_frame_size = 12;
3769 break;
3770 case 0x50:
3771 j->rec_frame_size = 6;
3772 break;
3773 default:
3774 j->rec_frame_size = 18;
3775 break;
3776 }
3777 j->rec_mode = 0;
3778 } else {
3779 retval = 1;
3780 }
3781 break;
3782 case ULAW:
3783 switch (j->baseframe.low) {
3784 case 0xA0:
3785 j->rec_frame_size = 80;
3786 break;
3787 case 0x50:
3788 j->rec_frame_size = 40;
3789 break;
3790 default:
3791 j->rec_frame_size = 120;
3792 break;
3793 }
3794 j->rec_mode = 4;
3795 break;
3796 case ALAW:
3797 switch (j->baseframe.low) {
3798 case 0xA0:
3799 j->rec_frame_size = 80;
3800 break;
3801 case 0x50:
3802 j->rec_frame_size = 40;
3803 break;
3804 default:
3805 j->rec_frame_size = 120;
3806 break;
3807 }
3808 j->rec_mode = 4;
3809 break;
3810 case LINEAR16:
3811 switch (j->baseframe.low) {
3812 case 0xA0:
3813 j->rec_frame_size = 160;
3814 break;
3815 case 0x50:
3816 j->rec_frame_size = 80;
3817 break;
3818 default:
3819 j->rec_frame_size = 240;
3820 break;
3821 }
3822 j->rec_mode = 5;
3823 break;
3824 case LINEAR8:
3825 switch (j->baseframe.low) {
3826 case 0xA0:
3827 j->rec_frame_size = 80;
3828 break;
3829 case 0x50:
3830 j->rec_frame_size = 40;
3831 break;
3832 default:
3833 j->rec_frame_size = 120;
3834 break;
3835 }
3836 j->rec_mode = 6;
3837 break;
3838 case WSS:
3839 switch (j->baseframe.low) {
3840 case 0xA0:
3841 j->rec_frame_size = 80;
3842 break;
3843 case 0x50:
3844 j->rec_frame_size = 40;
3845 break;
3846 default:
3847 j->rec_frame_size = 120;
3848 break;
3849 }
3850 j->rec_mode = 7;
3851 break;
3852 default:
3853 kfree(j->read_buffer);
3854 j->rec_frame_size = 0;
3855 j->rec_mode = -1;
3856 j->read_buffer = NULL;
3857 j->read_buffer_size = 0;
3858 retval = 1;
3859 break;
3860 }
3861 return retval;
3862 }
3863
3864 static int ixj_record_start(IXJ *j)
3865 {
3866 unsigned short cmd = 0x0000;
3867
3868 if (j->read_buffer) {
3869 ixj_record_stop(j);
3870 }
3871 j->flags.recording = 1;
3872 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874 if(ixjdebug & 0x0002)
3875 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877 if (!j->rec_mode) {
3878 switch (j->rec_codec) {
3879 case G723_63:
3880 cmd = 0x5131;
3881 break;
3882 case G723_53:
3883 cmd = 0x5132;
3884 break;
3885 case TS85:
3886 cmd = 0x5130; /* TrueSpeech 8.5 */
3887
3888 break;
3889 case TS48:
3890 cmd = 0x5133; /* TrueSpeech 4.8 */
3891
3892 break;
3893 case TS41:
3894 cmd = 0x5134; /* TrueSpeech 4.1 */
3895
3896 break;
3897 case G728:
3898 cmd = 0x5135;
3899 break;
3900 case G729:
3901 case G729B:
3902 cmd = 0x5136;
3903 break;
3904 default:
3905 return 1;
3906 }
3907 if (ixj_WriteDSPCommand(cmd, j))
3908 return -1;
3909 }
3910 if (!j->read_buffer) {
3911 if (!j->read_buffer)
3912 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913 if (!j->read_buffer) {
3914 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915 return -ENOMEM;
3916 }
3917 }
3918 j->read_buffer_size = j->rec_frame_size * 2;
3919
3920 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3921
3922 return -1;
3923
3924 switch (j->rec_mode) {
3925 case 0:
3926 cmd = 0x1C03; /* Record C1 */
3927
3928 break;
3929 case 4:
3930 if (j->ver.low == 0x12) {
3931 cmd = 0x1E03; /* Record C1 */
3932
3933 } else {
3934 cmd = 0x1E01; /* Record C1 */
3935
3936 }
3937 break;
3938 case 5:
3939 if (j->ver.low == 0x12) {
3940 cmd = 0x1E83; /* Record C1 */
3941
3942 } else {
3943 cmd = 0x1E81; /* Record C1 */
3944
3945 }
3946 break;
3947 case 6:
3948 if (j->ver.low == 0x12) {
3949 cmd = 0x1F03; /* Record C1 */
3950
3951 } else {
3952 cmd = 0x1F01; /* Record C1 */
3953
3954 }
3955 break;
3956 case 7:
3957 if (j->ver.low == 0x12) {
3958 cmd = 0x1F83; /* Record C1 */
3959 } else {
3960 cmd = 0x1F81; /* Record C1 */
3961 }
3962 break;
3963 }
3964 if (ixj_WriteDSPCommand(cmd, j))
3965 return -1;
3966
3967 if (j->flags.playing) {
3968 ixj_aec_start(j, j->aec_level);
3969 }
3970 return 0;
3971 }
3972
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975 if (ixjdebug & 0x0002)
3976 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978 kfree(j->read_buffer);
3979 j->read_buffer = NULL;
3980 j->read_buffer_size = 0;
3981 if (j->rec_mode > -1) {
3982 ixj_WriteDSPCommand(0x5120, j);
3983 j->rec_mode = -1;
3984 }
3985 j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989 if (arg)
3990 ixj_WriteDSPCommand(0x513F, j);
3991 else
3992 ixj_WriteDSPCommand(0x513E, j);
3993 }
3994
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997 if (depth > 60)
3998 depth = 60;
3999 if (depth < 0)
4000 depth = 0;
4001 ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006 ixj_WriteDSPCommand(0xCF07, j);
4007 ixj_WriteDSPCommand(volume, j);
4008 }
4009
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012 ixj_WriteDSPCommand(0xCF05, j);
4013 return j->ssr.high << 8 | j->ssr.low;
4014 }
4015
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018 if(j->aec_level == AEC_AGC) {
4019 if (ixjdebug & 0x0002)
4020 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021 ixj_WriteDSPCommand(0xCF96, j);
4022 ixj_WriteDSPCommand(volume, j);
4023 } else {
4024 if (ixjdebug & 0x0002)
4025 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026 ixj_WriteDSPCommand(0xCF03, j);
4027 ixj_WriteDSPCommand(volume, j);
4028 }
4029 }
4030
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033 int newvolume, dsprecmax;
4034
4035 if (ixjdebug & 0x0002)
4036 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037 if(volume > 100 || volume < 0) {
4038 return -1;
4039 }
4040
4041 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042 switch (j->cardtype) {
4043 case QTI_PHONEJACK:
4044 dsprecmax = 0x440;
4045 break;
4046 case QTI_LINEJACK:
4047 dsprecmax = 0x180;
4048 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4049 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4050 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4051 break;
4052 case QTI_PHONEJACK_LITE:
4053 dsprecmax = 0x4C0;
4054 break;
4055 case QTI_PHONEJACK_PCI:
4056 dsprecmax = 0x100;
4057 break;
4058 case QTI_PHONECARD:
4059 dsprecmax = 0x400;
4060 break;
4061 default:
4062 return -1;
4063 }
4064 newvolume = (dsprecmax * volume) / 100;
4065 set_rec_volume(j, newvolume);
4066 return 0;
4067 }
4068
4069 static int get_rec_volume(IXJ *j)
4070 {
4071 if(j->aec_level == AEC_AGC) {
4072 if (ixjdebug & 0x0002)
4073 printk(KERN_INFO "Getting AGC Threshold\n");
4074 ixj_WriteDSPCommand(0xCF86, j);
4075 if (ixjdebug & 0x0002)
4076 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077 return j->ssr.high << 8 | j->ssr.low;
4078 } else {
4079 if (ixjdebug & 0x0002)
4080 printk(KERN_INFO "Getting Record Volume\n");
4081 ixj_WriteDSPCommand(0xCF01, j);
4082 return j->ssr.high << 8 | j->ssr.low;
4083 }
4084 }
4085
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088 int volume, newvolume, dsprecmax;
4089
4090 switch (j->cardtype) {
4091 case QTI_PHONEJACK:
4092 dsprecmax = 0x440;
4093 break;
4094 case QTI_LINEJACK:
4095 dsprecmax = 0x180;
4096 break;
4097 case QTI_PHONEJACK_LITE:
4098 dsprecmax = 0x4C0;
4099 break;
4100 case QTI_PHONEJACK_PCI:
4101 dsprecmax = 0x100;
4102 break;
4103 case QTI_PHONECARD:
4104 dsprecmax = 0x400;
4105 break;
4106 default:
4107 return -1;
4108 }
4109 volume = get_rec_volume(j);
4110 newvolume = (volume * 100) / dsprecmax;
4111 if(newvolume > 100)
4112 newvolume = 100;
4113 return newvolume;
4114 }
4115
4116 static int get_rec_level(IXJ *j)
4117 {
4118 int retval;
4119
4120 ixj_WriteDSPCommand(0xCF88, j);
4121
4122 retval = j->ssr.high << 8 | j->ssr.low;
4123 retval = (retval * 256) / 240;
4124 return retval;
4125 }
4126
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129 j->aec_level = level;
4130 if (ixjdebug & 0x0002)
4131 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132 if (!level) {
4133 aec_stop(j);
4134 } else {
4135 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138 ixj_WriteDSPCommand(0x0300, j);
4139 }
4140 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144 switch (level) {
4145 case AEC_LOW:
4146 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148 ixj_WriteDSPCommand(0xE011, j);
4149 ixj_WriteDSPCommand(0xFFFF, j);
4150
4151 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152 ixj_WriteDSPCommand(0x0000, j); /* to off */
4153
4154 break;
4155
4156 case AEC_MED:
4157 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159 ixj_WriteDSPCommand(0xE011, j);
4160 ixj_WriteDSPCommand(0x0080, j);
4161
4162 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163 ixj_WriteDSPCommand(0x0000, j); /* to off */
4164
4165 break;
4166
4167 case AEC_HIGH:
4168 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170 ixj_WriteDSPCommand(0xE011, j);
4171 ixj_WriteDSPCommand(0x0080, j);
4172
4173 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174 ixj_WriteDSPCommand(0x0000, j); /* to off */
4175
4176 break;
4177
4178 case AEC_AGC:
4179 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182 ixj_WriteDSPCommand(0xE011, j);
4183 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188 ixj_WriteDSPCommand(0x0224, j);
4189 else
4190 ixj_WriteDSPCommand(0x1224, j);
4191
4192 ixj_WriteDSPCommand(0xE014, j);
4193 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4194
4195 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197 /* Now we can set the AGC initial parameters and turn it on */
4198 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4199 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220 ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222 break;
4223
4224 case AEC_AUTO:
4225 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227 ixj_WriteDSPCommand(0xE011, j);
4228 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233 ixj_WriteDSPCommand(0x0224, j);
4234 else
4235 ixj_WriteDSPCommand(0x1224, j);
4236
4237 ixj_WriteDSPCommand(0xE014, j);
4238 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4239
4240 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242 break;
4243 }
4244 }
4245 }
4246
4247 static void aec_stop(IXJ *j)
4248 {
4249 j->aec_level = AEC_OFF;
4250 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253 ixj_WriteDSPCommand(0x0700, j);
4254 }
4255 if (j->play_mode != -1 && j->rec_mode != -1)
4256 {
4257 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258 }
4259 }
4260
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263 int retval = 0;
4264
4265 j->play_codec = rate;
4266
4267 switch (rate) {
4268 case G723_63:
4269 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270 j->play_frame_size = 12;
4271 j->play_mode = 0;
4272 } else {
4273 retval = 1;
4274 }
4275 break;
4276 case G723_53:
4277 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278 j->play_frame_size = 10;
4279 j->play_mode = 0;
4280 } else {
4281 retval = 1;
4282 }
4283 break;
4284 case TS85:
4285 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286 j->play_frame_size = 16;
4287 j->play_mode = 0;
4288 } else {
4289 retval = 1;
4290 }
4291 break;
4292 case TS48:
4293 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294 j->play_frame_size = 9;
4295 j->play_mode = 0;
4296 } else {
4297 retval = 1;
4298 }
4299 break;
4300 case TS41:
4301 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302 j->play_frame_size = 8;
4303 j->play_mode = 0;
4304 } else {
4305 retval = 1;
4306 }
4307 break;
4308 case G728:
4309 if (j->dsp.low != 0x20) {
4310 j->play_frame_size = 48;
4311 j->play_mode = 0;
4312 } else {
4313 retval = 1;
4314 }
4315 break;
4316 case G729:
4317 if (j->dsp.low != 0x20) {
4318 if (!j->flags.g729_loaded) {
4319 retval = 1;
4320 break;
4321 }
4322 switch (j->baseframe.low) {
4323 case 0xA0:
4324 j->play_frame_size = 10;
4325 break;
4326 case 0x50:
4327 j->play_frame_size = 5;
4328 break;
4329 default:
4330 j->play_frame_size = 15;
4331 break;
4332 }
4333 j->play_mode = 0;
4334 } else {
4335 retval = 1;
4336 }
4337 break;
4338 case G729B:
4339 if (j->dsp.low != 0x20) {
4340 if (!j->flags.g729_loaded) {
4341 retval = 1;
4342 break;
4343 }
4344 switch (j->baseframe.low) {
4345 case 0xA0:
4346 j->play_frame_size = 12;
4347 break;
4348 case 0x50:
4349 j->play_frame_size = 6;
4350 break;
4351 default:
4352 j->play_frame_size = 18;
4353 break;
4354 }
4355 j->play_mode = 0;
4356 } else {
4357 retval = 1;
4358 }
4359 break;
4360 case ULAW:
4361 switch (j->baseframe.low) {
4362 case 0xA0:
4363 j->play_frame_size = 80;
4364 break;
4365 case 0x50:
4366 j->play_frame_size = 40;
4367 break;
4368 default:
4369 j->play_frame_size = 120;
4370 break;
4371 }
4372 j->play_mode = 2;
4373 break;
4374 case ALAW:
4375 switch (j->baseframe.low) {
4376 case 0xA0:
4377 j->play_frame_size = 80;
4378 break;
4379 case 0x50:
4380 j->play_frame_size = 40;
4381 break;
4382 default:
4383 j->play_frame_size = 120;
4384 break;
4385 }
4386 j->play_mode = 2;
4387 break;
4388 case LINEAR16:
4389 switch (j->baseframe.low) {
4390 case 0xA0:
4391 j->play_frame_size = 160;
4392 break;
4393 case 0x50:
4394 j->play_frame_size = 80;
4395 break;
4396 default:
4397 j->play_frame_size = 240;
4398 break;
4399 }
4400 j->play_mode = 6;
4401 break;
4402 case LINEAR8:
4403 switch (j->baseframe.low) {
4404 case 0xA0:
4405 j->play_frame_size = 80;
4406 break;
4407 case 0x50:
4408 j->play_frame_size = 40;
4409 break;
4410 default:
4411 j->play_frame_size = 120;
4412 break;
4413 }
4414 j->play_mode = 4;
4415 break;
4416 case WSS:
4417 switch (j->baseframe.low) {
4418 case 0xA0:
4419 j->play_frame_size = 80;
4420 break;
4421 case 0x50:
4422 j->play_frame_size = 40;
4423 break;
4424 default:
4425 j->play_frame_size = 120;
4426 break;
4427 }
4428 j->play_mode = 5;
4429 break;
4430 default:
4431 kfree(j->write_buffer);
4432 j->play_frame_size = 0;
4433 j->play_mode = -1;
4434 j->write_buffer = NULL;
4435 j->write_buffer_size = 0;
4436 retval = 1;
4437 break;
4438 }
4439 return retval;
4440 }
4441
4442 static int ixj_play_start(IXJ *j)
4443 {
4444 unsigned short cmd = 0x0000;
4445
4446 if (j->write_buffer) {
4447 ixj_play_stop(j);
4448 }
4449
4450 if(ixjdebug & 0x0002)
4451 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453 j->flags.playing = 1;
4454 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456 j->flags.play_first_frame = 1;
4457 j->drybuffer = 0;
4458
4459 if (!j->play_mode) {
4460 switch (j->play_codec) {
4461 case G723_63:
4462 cmd = 0x5231;
4463 break;
4464 case G723_53:
4465 cmd = 0x5232;
4466 break;
4467 case TS85:
4468 cmd = 0x5230; /* TrueSpeech 8.5 */
4469
4470 break;
4471 case TS48:
4472 cmd = 0x5233; /* TrueSpeech 4.8 */
4473
4474 break;
4475 case TS41:
4476 cmd = 0x5234; /* TrueSpeech 4.1 */
4477
4478 break;
4479 case G728:
4480 cmd = 0x5235;
4481 break;
4482 case G729:
4483 case G729B:
4484 cmd = 0x5236;
4485 break;
4486 default:
4487 return 1;
4488 }
4489 if (ixj_WriteDSPCommand(cmd, j))
4490 return -1;
4491 }
4492 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493 if (!j->write_buffer) {
4494 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495 return -ENOMEM;
4496 }
4497 /* j->write_buffers_empty = 2; */
4498 j->write_buffers_empty = 1;
4499 j->write_buffer_size = j->play_frame_size * 2;
4500 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4504
4505 return -1;
4506
4507 switch (j->play_mode) {
4508 case 0:
4509 cmd = 0x2C03;
4510 break;
4511 case 2:
4512 if (j->ver.low == 0x12) {
4513 cmd = 0x2C23;
4514 } else {
4515 cmd = 0x2C21;
4516 }
4517 break;
4518 case 4:
4519 if (j->ver.low == 0x12) {
4520 cmd = 0x2C43;
4521 } else {
4522 cmd = 0x2C41;
4523 }
4524 break;
4525 case 5:
4526 if (j->ver.low == 0x12) {
4527 cmd = 0x2C53;
4528 } else {
4529 cmd = 0x2C51;
4530 }
4531 break;
4532 case 6:
4533 if (j->ver.low == 0x12) {
4534 cmd = 0x2C63;
4535 } else {
4536 cmd = 0x2C61;
4537 }
4538 break;
4539 }
4540 if (ixj_WriteDSPCommand(cmd, j))
4541 return -1;
4542
4543 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4544 return -1;
4545
4546 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4547 return -1;
4548
4549 if (j->flags.recording) {
4550 ixj_aec_start(j, j->aec_level);
4551 }
4552
4553 return 0;
4554 }
4555
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558 if (ixjdebug & 0x0002)
4559 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561 kfree(j->write_buffer);
4562 j->write_buffer = NULL;
4563 j->write_buffer_size = 0;
4564 if (j->play_mode > -1) {
4565 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4566
4567 j->play_mode = -1;
4568 }
4569 j->flags.playing = 0;
4570 }
4571
4572 static inline int get_play_level(IXJ *j)
4573 {
4574 int retval;
4575
4576 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577 return j->ssr.high << 8 | j->ssr.low;
4578 retval = j->ssr.high << 8 | j->ssr.low;
4579 retval = (retval * 256) / 240;
4580 return retval;
4581 }
4582
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585 unsigned int mask = 0;
4586
4587 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588
4589 poll_wait(file_p, &(j->poll_q), wait);
4590 if (j->read_buffer_ready > 0)
4591 mask |= POLLIN | POLLRDNORM; /* readable */
4592 if (j->write_buffers_empty > 0)
4593 mask |= POLLOUT | POLLWRNORM; /* writable */
4594 if (j->ex.bytes)
4595 mask |= POLLPRI;
4596 return mask;
4597 }
4598
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601 if (!j->tone_state) {
4602 if(ixjdebug & 0x0002) {
4603 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604 }
4605 if (j->dsp.low == 0x20) {
4606 idle(j);
4607 }
4608 j->tone_start_jif = jiffies;
4609
4610 j->tone_state = 1;
4611 }
4612
4613 j->tone_index = tone;
4614 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615 return -1;
4616
4617 return 0;
4618 }
4619
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622 j->tone_on_time = arg;
4623
4624 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4625
4626 return -1;
4627
4628 if (ixj_WriteDSPCommand(arg, j))
4629 return -1;
4630
4631 return 0;
4632 }
4633
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636 int cnt;
4637
4638 j->pld_scrr.byte = inb_p(j->XILINXbase);
4639 if (!j->pld_scrr.bits.sci) {
4640 for (cnt = 0; cnt < 10; cnt++) {
4641 udelay(32);
4642 j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644 if ((j->pld_scrr.bits.sci))
4645 return 1;
4646 }
4647 if (ixjdebug & 0x0001)
4648 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649 return 0;
4650 } else
4651 return 1;
4652 }
4653
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656 int cnt;
4657
4658 j->pld_scrr.byte = inb_p(j->XILINXbase);
4659 if (j->pld_scrr.bits.sci) {
4660 for (cnt = 0; cnt < 10; cnt++) {
4661 udelay(32);
4662 j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664 if (!(j->pld_scrr.bits.sci))
4665 return 1;
4666 }
4667 if (ixjdebug & 0x0001)
4668 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669 return 0;
4670 } else
4671 return 1;
4672 }
4673
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676 switch (control) {
4677 case SCI_End:
4678 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4679
4680 j->pld_scrw.bits.c1 = 0; /* to no selection */
4681
4682 break;
4683 case SCI_Enable_DAA:
4684 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4685
4686 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4687
4688 break;
4689 case SCI_Enable_Mixer:
4690 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4691
4692 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4693
4694 break;
4695 case SCI_Enable_EEPROM:
4696 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4697
4698 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4699
4700 break;
4701 default:
4702 return 0;
4703 break;
4704 }
4705 outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707 switch (control) {
4708 case SCI_End:
4709 return 1;
4710 break;
4711 case SCI_Enable_DAA:
4712 case SCI_Enable_Mixer:
4713 case SCI_Enable_EEPROM:
4714 if (!SCI_WaitHighSCI(j))
4715 return 0;
4716 break;
4717 default:
4718 return 0;
4719 break;
4720 }
4721 return 1;
4722 }
4723
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726 if (!SCI_Control(j, SCI_End))
4727 return 0;
4728
4729 if (!SCI_WaitLowSCI(j))
4730 return 0;
4731
4732 return 1;
4733 }
4734
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737 int reg = (val & 0x1F00) >> 8;
4738 return j->mix.vol[reg];
4739 }
4740
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743 BYTES bytes;
4744
4745 bytes.high = (val & 0x1F00) >> 8;
4746 bytes.low = val & 0x00FF;
4747
4748 /* save mixer value so we can get back later on */
4749 j->mix.vol[bytes.high] = bytes.low;
4750
4751 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4752
4753 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4754
4755 SCI_Control(j, SCI_Enable_Mixer);
4756
4757 SCI_Control(j, SCI_End);
4758
4759 return 0;
4760 }
4761
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766 if (!SCI_Control(j, SCI_Enable_DAA))
4767 return 0;
4768 else
4769 return 1;
4770 }
4771
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774 BYTES bytes;
4775
4776 switch (j->daa_mode) {
4777 case SOP_PU_SLEEP:
4778 bytes.high = 0x14;
4779 break;
4780 case SOP_PU_RINGING:
4781 bytes.high = 0x54;
4782 break;
4783 case SOP_PU_CONVERSATION:
4784 bytes.high = 0x94;
4785 break;
4786 case SOP_PU_PULSEDIALING:
4787 bytes.high = 0xD4;
4788 break;
4789 }
4790
4791 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794 case 0:
4795 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796 break;
4797 case 1:
4798 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799 break;
4800 case 2:
4801 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802 break;
4803 case 3:
4804 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805 break;
4806 }
4807
4808 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810 if (!daa_load(&bytes, j))
4811 return 0;
4812
4813 if (!SCI_Prepare(j))
4814 return 0;
4815
4816 return 1;
4817 }
4818
4819 static char daa_int_read(IXJ *j)
4820 {
4821 BYTES bytes;
4822
4823 if (!SCI_Prepare(j))
4824 return 0;
4825
4826 bytes.high = 0x38;
4827 bytes.low = 0x00;
4828 outb_p(bytes.high, j->XILINXbase + 0x03);
4829 outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831 if (!SCI_Control(j, SCI_Enable_DAA))
4832 return 0;
4833
4834 bytes.high = inb_p(j->XILINXbase + 0x03);
4835 bytes.low = inb_p(j->XILINXbase + 0x02);
4836 if (bytes.low != ALISDAA_ID_BYTE) {
4837 if (ixjdebug & 0x0001)
4838 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839 return 0;
4840 }
4841 if (!SCI_Control(j, SCI_Enable_DAA))
4842 return 0;
4843 if (!SCI_Control(j, SCI_End))
4844 return 0;
4845
4846 bytes.high = inb_p(j->XILINXbase + 0x03);
4847 bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851 return 1;
4852 }
4853
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856 IXJ_WORD wdata;
4857 BYTES bytes;
4858
4859 if (!SCI_Prepare(j))
4860 return 0;
4861
4862 switch (j->daa_mode) {
4863 case SOP_PU_SLEEP:
4864 bytes.high = 0x30 + cr;
4865 break;
4866 case SOP_PU_RINGING:
4867 bytes.high = 0x70 + cr;
4868 break;
4869 case SOP_PU_CONVERSATION:
4870 bytes.high = 0xB0 + cr;
4871 break;
4872 case SOP_PU_PULSEDIALING:
4873 default:
4874 bytes.high = 0xF0 + cr;
4875 break;
4876 }
4877
4878 bytes.low = 0x00;
4879
4880 outb_p(bytes.high, j->XILINXbase + 0x03);
4881 outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883 if (!SCI_Control(j, SCI_Enable_DAA))
4884 return 0;
4885
4886 bytes.high = inb_p(j->XILINXbase + 0x03);
4887 bytes.low = inb_p(j->XILINXbase + 0x02);
4888 if (bytes.low != ALISDAA_ID_BYTE) {
4889 if (ixjdebug & 0x0001)
4890 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891 return 0;
4892 }
4893 if (!SCI_Control(j, SCI_Enable_DAA))
4894 return 0;
4895 if (!SCI_Control(j, SCI_End))
4896 return 0;
4897
4898 wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900 switch(cr){
4901 case 5:
4902 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903 break;
4904 case 4:
4905 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906 break;
4907 case 3:
4908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909 break;
4910 case 2:
4911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912 break;
4913 case 1:
4914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915 break;
4916 case 0:
4917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918 break;
4919 default:
4920 return 0;
4921 }
4922 return 1;
4923 }
4924
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927 int i;
4928 BYTES bytes;
4929
4930 if (ixjdebug & 0x0002)
4931 printk("DAA Clearing CID ram\n");
4932
4933 if (!SCI_Prepare(j))
4934 return 0;
4935
4936 bytes.high = 0x58;
4937 bytes.low = 0x00;
4938 outb_p(bytes.high, j->XILINXbase + 0x03);
4939 outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941 if (!SCI_Control(j, SCI_Enable_DAA))
4942 return 0;
4943
4944 if (!SCI_WaitHighSCI(j))
4945 return 0;
4946
4947 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948 bytes.high = bytes.low = 0x00;
4949 outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951 if (i < ALISDAA_CALLERID_SIZE - 1)
4952 outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954 if (!SCI_Control(j, SCI_Enable_DAA))
4955 return 0;
4956
4957 if (!SCI_WaitHighSCI(j))
4958 return 0;
4959
4960 }
4961
4962 if (!SCI_Control(j, SCI_End))
4963 return 0;
4964
4965 if (ixjdebug & 0x0002)
4966 printk("DAA CID ram cleared\n");
4967
4968 return 1;
4969 }
4970
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973 int i;
4974 BYTES bytes;
4975 char CID[ALISDAA_CALLERID_SIZE];
4976 bool mContinue;
4977 char *pIn, *pOut;
4978
4979 if (!SCI_Prepare(j))
4980 return 0;
4981
4982 bytes.high = 0x78;
4983 bytes.low = 0x00;
4984 outb_p(bytes.high, j->XILINXbase + 0x03);
4985 outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987 if (!SCI_Control(j, SCI_Enable_DAA))
4988 return 0;
4989
4990 if (!SCI_WaitHighSCI(j))
4991 return 0;
4992
4993 bytes.high = inb_p(j->XILINXbase + 0x03);
4994 bytes.low = inb_p(j->XILINXbase + 0x02);
4995 if (bytes.low != ALISDAA_ID_BYTE) {
4996 if (ixjdebug & 0x0001)
4997 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998 return 0;
4999 }
5000 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001 bytes.high = bytes.low = 0x00;
5002 outb_p(bytes.high, j->XILINXbase + 0x03);
5003 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005 if (!SCI_Control(j, SCI_Enable_DAA))
5006 return 0;
5007
5008 if (!SCI_WaitHighSCI(j))
5009 return 0;
5010
5011 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013 }
5014
5015 if (!SCI_Control(j, SCI_End))
5016 return 0;
5017
5018 pIn = CID;
5019 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020 mContinue = true;
5021 while (mContinue) {
5022 if ((pIn[1] & 0x03) == 0x01) {
5023 pOut[0] = pIn[0];
5024 }
5025 if ((pIn[2] & 0x0c) == 0x04) {
5026 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027 }
5028 if ((pIn[3] & 0x30) == 0x10) {
5029 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030 }
5031 if ((pIn[4] & 0xc0) == 0x40) {
5032 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033 } else {
5034 mContinue = false;
5035 }
5036 pIn += 5, pOut += 4;
5037 }
5038 memset(&j->cid, 0, sizeof(PHONE_CID));
5039 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040 pOut += 4;
5041 strncpy(j->cid.month, pOut, 2);
5042 pOut += 2;
5043 strncpy(j->cid.day, pOut, 2);
5044 pOut += 2;
5045 strncpy(j->cid.hour, pOut, 2);
5046 pOut += 2;
5047 strncpy(j->cid.min, pOut, 2);
5048 pOut += 3;
5049 j->cid.numlen = *pOut;
5050 pOut += 1;
5051 strncpy(j->cid.number, pOut, j->cid.numlen);
5052 pOut += j->cid.numlen + 1;
5053 j->cid.namelen = *pOut;
5054 pOut += 1;
5055 strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057 ixj_daa_cid_reset(j);
5058 return 1;
5059 }
5060
5061 static char daa_get_version(IXJ *j)
5062 {
5063 BYTES bytes;
5064
5065 if (!SCI_Prepare(j))
5066 return 0;
5067
5068 bytes.high = 0x35;
5069 bytes.low = 0x00;
5070 outb_p(bytes.high, j->XILINXbase + 0x03);
5071 outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073 if (!SCI_Control(j, SCI_Enable_DAA))
5074 return 0;
5075
5076 bytes.high = inb_p(j->XILINXbase + 0x03);
5077 bytes.low = inb_p(j->XILINXbase + 0x02);
5078 if (bytes.low != ALISDAA_ID_BYTE) {
5079 if (ixjdebug & 0x0001)
5080 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081 return 0;
5082 }
5083 if (!SCI_Control(j, SCI_Enable_DAA))
5084 return 0;
5085
5086 if (!SCI_Control(j, SCI_End))
5087 return 0;
5088
5089 bytes.high = inb_p(j->XILINXbase + 0x03);
5090 bytes.low = inb_p(j->XILINXbase + 0x02);
5091 if (ixjdebug & 0x0002)
5092 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094 return bytes.high;
5095 }
5096
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099 /* NOTE:
5100 The DAA *MUST* be in the conversation mode if the
5101 PSTN line is to be seized (PSTN line off-hook).
5102 Taking the PSTN line off-hook while the DAA is in
5103 a mode other than conversation mode will cause a
5104 hardware failure of the ALIS-A part.
5105
5106 NOTE:
5107 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108 if the PSTN line is on-hook. Failure to have the PSTN line
5109 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110 ALIS-A part.
5111 */
5112
5113 BYTES bytes;
5114
5115 j->flags.pstn_rmr = 0;
5116
5117 if (!SCI_Prepare(j))
5118 return 0;
5119
5120 switch (mode) {
5121 case SOP_PU_RESET:
5122 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5123
5124 outb_p(j->pld_scrw.byte, j->XILINXbase);
5125 j->pld_slicw.bits.rly2 = 0;
5126 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127 bytes.high = 0x10;
5128 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129 daa_load(&bytes, j);
5130 if (!SCI_Prepare(j))
5131 return 0;
5132
5133 j->daa_mode = SOP_PU_SLEEP;
5134 break;
5135 case SOP_PU_SLEEP:
5136 if(j->daa_mode == SOP_PU_SLEEP)
5137 {
5138 break;
5139 }
5140 if (ixjdebug & 0x0008)
5141 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5143 {
5144 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5145
5146 outb_p(j->pld_scrw.byte, j->XILINXbase);
5147 j->pld_slicw.bits.rly2 = 0;
5148 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149 bytes.high = 0x10;
5150 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151 daa_load(&bytes, j);
5152 if (!SCI_Prepare(j))
5153 return 0;
5154 }
5155 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5156
5157 outb_p(j->pld_scrw.byte, j->XILINXbase);
5158 j->pld_slicw.bits.rly2 = 0;
5159 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160 bytes.high = 0x10;
5161 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162 daa_load(&bytes, j);
5163 if (!SCI_Prepare(j))
5164 return 0;
5165
5166 j->daa_mode = SOP_PU_SLEEP;
5167 j->flags.pstn_ringing = 0;
5168 j->ex.bits.pstn_ring = 0;
5169 j->pstn_sleeptil = jiffies + (hertz / 4);
5170 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5172 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5173 break;
5174 case SOP_PU_RINGING:
5175 if (ixjdebug & 0x0008)
5176 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5178
5179 outb_p(j->pld_scrw.byte, j->XILINXbase);
5180 j->pld_slicw.bits.rly2 = 0;
5181 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182 bytes.high = 0x50;
5183 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184 daa_load(&bytes, j);
5185 if (!SCI_Prepare(j))
5186 return 0;
5187 j->daa_mode = SOP_PU_RINGING;
5188 break;
5189 case SOP_PU_CONVERSATION:
5190 if (ixjdebug & 0x0008)
5191 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192 bytes.high = 0x90;
5193 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194 daa_load(&bytes, j);
5195 if (!SCI_Prepare(j))
5196 return 0;
5197 j->pld_slicw.bits.rly2 = 1;
5198 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5200
5201 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202 j->daa_mode = SOP_PU_CONVERSATION;
5203 j->flags.pstn_ringing = 0;
5204 j->ex.bits.pstn_ring = 0;
5205 j->pstn_sleeptil = jiffies;
5206 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207 break;
5208 case SOP_PU_PULSEDIALING:
5209 if (ixjdebug & 0x0008)
5210 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5212
5213 outb_p(j->pld_scrw.byte, j->XILINXbase);
5214 j->pld_slicw.bits.rly2 = 0;
5215 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216 bytes.high = 0xD0;
5217 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218 daa_load(&bytes, j);
5219 if (!SCI_Prepare(j))
5220 return 0;
5221 j->daa_mode = SOP_PU_PULSEDIALING;
5222 break;
5223 default:
5224 break;
5225 }
5226 return 1;
5227 }
5228
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231 BYTES bytes;
5232
5233 j->flags.pstncheck = 1;
5234
5235 daa_set_mode(j, SOP_PU_SLEEP);
5236
5237 if (!SCI_Prepare(j))
5238 return 0;
5239
5240 outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242 bytes.high = 0x14;
5243 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244 if (!daa_load(&bytes, j))
5245 return 0;
5246
5247 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249 if (!daa_load(&bytes, j))
5250 return 0;
5251
5252 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254 if (!daa_load(&bytes, j))
5255 return 0;
5256
5257 if (!SCI_Prepare(j))
5258 return 0;
5259
5260 bytes.high = 0x1F;
5261 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262 if (!daa_load(&bytes, j))
5263 return 0;
5264
5265 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267 if (!daa_load(&bytes, j))
5268 return 0;
5269
5270 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272 if (!daa_load(&bytes, j))
5273 return 0;
5274
5275 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277 if (!daa_load(&bytes, j))
5278 return 0;
5279
5280 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281 bytes.low = 0x00;
5282 if (!daa_load(&bytes, j))
5283 return 0;
5284
5285 if (!SCI_Prepare(j))
5286 return 0;
5287
5288 bytes.high = 0x00;
5289 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290 if (!daa_load(&bytes, j))
5291 return 0;
5292
5293 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295 if (!daa_load(&bytes, j))
5296 return 0;
5297
5298 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300 if (!daa_load(&bytes, j))
5301 return 0;
5302
5303 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305 if (!daa_load(&bytes, j))
5306 return 0;
5307
5308 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309 bytes.low = 0x00;
5310 if (!daa_load(&bytes, j))
5311 return 0;
5312
5313 if (!SCI_Control(j, SCI_End))
5314 return 0;
5315 if (!SCI_WaitLowSCI(j))
5316 return 0;
5317
5318 bytes.high = 0x01;
5319 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320 if (!daa_load(&bytes, j))
5321 return 0;
5322
5323 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325 if (!daa_load(&bytes, j))
5326 return 0;
5327
5328 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330 if (!daa_load(&bytes, j))
5331 return 0;
5332
5333 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335 if (!daa_load(&bytes, j))
5336 return 0;
5337
5338 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339 bytes.low = 0x00;
5340 if (!daa_load(&bytes, j))
5341 return 0;
5342
5343 if (!SCI_Control(j, SCI_End))
5344 return 0;
5345 if (!SCI_WaitLowSCI(j))
5346 return 0;
5347
5348 bytes.high = 0x02;
5349 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350 if (!daa_load(&bytes, j))
5351 return 0;
5352
5353 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355 if (!daa_load(&bytes, j))
5356 return 0;
5357
5358 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360 if (!daa_load(&bytes, j))
5361 return 0;
5362
5363 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365 if (!daa_load(&bytes, j))
5366 return 0;
5367
5368 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369 bytes.low = 0x00;
5370 if (!daa_load(&bytes, j))
5371 return 0;
5372
5373 if (!SCI_Control(j, SCI_End))
5374 return 0;
5375 if (!SCI_WaitLowSCI(j))
5376 return 0;
5377
5378 bytes.high = 0x03;
5379 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380 if (!daa_load(&bytes, j))
5381 return 0;
5382
5383 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385 if (!daa_load(&bytes, j))
5386 return 0;
5387
5388 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390 if (!daa_load(&bytes, j))
5391 return 0;
5392
5393 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395 if (!daa_load(&bytes, j))
5396 return 0;
5397
5398 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399 bytes.low = 0x00;
5400 if (!daa_load(&bytes, j))
5401 return 0;
5402
5403 if (!SCI_Control(j, SCI_End))
5404 return 0;
5405 if (!SCI_WaitLowSCI(j))
5406 return 0;
5407
5408 bytes.high = 0x04;
5409 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410 if (!daa_load(&bytes, j))
5411 return 0;
5412
5413 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415 if (!daa_load(&bytes, j))
5416 return 0;
5417
5418 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420 if (!daa_load(&bytes, j))
5421 return 0;
5422
5423 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425 if (!daa_load(&bytes, j))
5426 return 0;
5427
5428 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429 bytes.low = 0x00;
5430 if (!daa_load(&bytes, j))
5431 return 0;
5432
5433 if (!SCI_Control(j, SCI_End))
5434 return 0;
5435 if (!SCI_WaitLowSCI(j))
5436 return 0;
5437
5438 bytes.high = 0x05;
5439 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440 if (!daa_load(&bytes, j))
5441 return 0;
5442
5443 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445 if (!daa_load(&bytes, j))
5446 return 0;
5447
5448 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450 if (!daa_load(&bytes, j))
5451 return 0;
5452
5453 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455 if (!daa_load(&bytes, j))
5456 return 0;
5457
5458 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459 bytes.low = 0x00;
5460 if (!daa_load(&bytes, j))
5461 return 0;
5462
5463 if (!SCI_Control(j, SCI_End))
5464 return 0;
5465 if (!SCI_WaitLowSCI(j))
5466 return 0;
5467
5468 bytes.high = 0x06;
5469 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470 if (!daa_load(&bytes, j))
5471 return 0;
5472
5473 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475 if (!daa_load(&bytes, j))
5476 return 0;
5477
5478 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480 if (!daa_load(&bytes, j))
5481 return 0;
5482
5483 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485 if (!daa_load(&bytes, j))
5486 return 0;
5487
5488 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489 bytes.low = 0x00;
5490 if (!daa_load(&bytes, j))
5491 return 0;
5492
5493 if (!SCI_Control(j, SCI_End))
5494 return 0;
5495 if (!SCI_WaitLowSCI(j))
5496 return 0;
5497
5498 bytes.high = 0x07;
5499 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500 if (!daa_load(&bytes, j))
5501 return 0;
5502
5503 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505 if (!daa_load(&bytes, j))
5506 return 0;
5507
5508 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510 if (!daa_load(&bytes, j))
5511 return 0;
5512
5513 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515 if (!daa_load(&bytes, j))
5516 return 0;
5517
5518 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519 bytes.low = 0x00;
5520 if (!daa_load(&bytes, j))
5521 return 0;
5522
5523 if (!SCI_Control(j, SCI_End))
5524 return 0;
5525 if (!SCI_WaitLowSCI(j))
5526 return 0;
5527
5528 bytes.high = 0x08;
5529 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530 if (!daa_load(&bytes, j))
5531 return 0;
5532
5533 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535 if (!daa_load(&bytes, j))
5536 return 0;
5537
5538 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540 if (!daa_load(&bytes, j))
5541 return 0;
5542
5543 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545 if (!daa_load(&bytes, j))
5546 return 0;
5547
5548 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549 bytes.low = 0x00;
5550 if (!daa_load(&bytes, j))
5551 return 0;
5552
5553 if (!SCI_Control(j, SCI_End))
5554 return 0;
5555 if (!SCI_WaitLowSCI(j))
5556 return 0;
5557
5558 bytes.high = 0x09;
5559 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560 if (!daa_load(&bytes, j))
5561 return 0;
5562
5563 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565 if (!daa_load(&bytes, j))
5566 return 0;
5567
5568 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569 bytes.low = 0x00;
5570 if (!daa_load(&bytes, j))
5571 return 0;
5572
5573 if (!SCI_Control(j, SCI_End))
5574 return 0;
5575 if (!SCI_WaitLowSCI(j))
5576 return 0;
5577
5578 bytes.high = 0x0A;
5579 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580 if (!daa_load(&bytes, j))
5581 return 0;
5582
5583 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585 if (!daa_load(&bytes, j))
5586 return 0;
5587
5588 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589 bytes.low = 0x00;
5590 if (!daa_load(&bytes, j))
5591 return 0;
5592
5593 if (!SCI_Control(j, SCI_End))
5594 return 0;
5595 if (!SCI_WaitLowSCI(j))
5596 return 0;
5597
5598 bytes.high = 0x0B;
5599 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600 if (!daa_load(&bytes, j))
5601 return 0;
5602
5603 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605 if (!daa_load(&bytes, j))
5606 return 0;
5607
5608 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609 bytes.low = 0x00;
5610 if (!daa_load(&bytes, j))
5611 return 0;
5612
5613 if (!SCI_Control(j, SCI_End))
5614 return 0;
5615 if (!SCI_WaitLowSCI(j))
5616 return 0;
5617
5618 bytes.high = 0x0C;
5619 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620 if (!daa_load(&bytes, j))
5621 return 0;
5622
5623 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625 if (!daa_load(&bytes, j))
5626 return 0;
5627
5628 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629 bytes.low = 0x00;
5630 if (!daa_load(&bytes, j))
5631 return 0;
5632
5633 if (!SCI_Control(j, SCI_End))
5634 return 0;
5635 if (!SCI_WaitLowSCI(j))
5636 return 0;
5637
5638 bytes.high = 0x0D;
5639 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640 if (!daa_load(&bytes, j))
5641 return 0;
5642
5643 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645 if (!daa_load(&bytes, j))
5646 return 0;
5647
5648 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649 bytes.low = 0x00;
5650 if (!daa_load(&bytes, j))
5651 return 0;
5652
5653 if (!SCI_Control(j, SCI_End))
5654 return 0;
5655 if (!SCI_WaitLowSCI(j))
5656 return 0;
5657
5658 bytes.high = 0x0E;
5659 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660 if (!daa_load(&bytes, j))
5661 return 0;
5662
5663 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665 if (!daa_load(&bytes, j))
5666 return 0;
5667
5668 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670 if (!daa_load(&bytes, j))
5671 return 0;
5672
5673 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675 if (!daa_load(&bytes, j))
5676 return 0;
5677
5678 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679 bytes.low = 0x00;
5680 if (!daa_load(&bytes, j))
5681 return 0;
5682
5683 if (!SCI_Control(j, SCI_End))
5684 return 0;
5685 if (!SCI_WaitLowSCI(j))
5686 return 0;
5687
5688 bytes.high = 0x0F;
5689 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690 if (!daa_load(&bytes, j))
5691 return 0;
5692
5693 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695 if (!daa_load(&bytes, j))
5696 return 0;
5697
5698 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700 if (!daa_load(&bytes, j))
5701 return 0;
5702
5703 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705 if (!daa_load(&bytes, j))
5706 return 0;
5707
5708 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709 bytes.low = 0x00;
5710 if (!daa_load(&bytes, j))
5711 return 0;
5712
5713 udelay(32);
5714 j->pld_scrr.byte = inb_p(j->XILINXbase);
5715 if (!SCI_Control(j, SCI_End))
5716 return 0;
5717
5718 outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720 if (ixjdebug & 0x0002)
5721 printk("DAA Coefficients Loaded\n");
5722
5723 j->flags.pstncheck = 0;
5724 return 1;
5725 }
5726
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729 j->tone_off_time = arg;
5730 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5731
5732 return -1;
5733 if (ixj_WriteDSPCommand(arg, j))
5734 return -1;
5735 return 0;
5736 }
5737
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5741
5742 return -1;
5743 return 0;
5744 }
5745
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5749
5750 return -1;
5751 return 0;
5752 }
5753
5754 static void ixj_busytone(IXJ *j)
5755 {
5756 j->flags.ringback = 0;
5757 j->flags.dialtone = 0;
5758 j->flags.busytone = 1;
5759 ixj_set_tone_on(0x07D0, j);
5760 ixj_set_tone_off(0x07D0, j);
5761 ixj_play_tone(j, 27);
5762 }
5763
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766 j->flags.ringback = 0;
5767 j->flags.dialtone = 1;
5768 j->flags.busytone = 0;
5769 if (j->dsp.low == 0x20) {
5770 return;
5771 } else {
5772 ixj_set_tone_on(0xFFFF, j);
5773 ixj_set_tone_off(0x0000, j);
5774 ixj_play_tone(j, 25);
5775 }
5776 }
5777
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780 if(j->tone_state || j->tone_cadence_state)
5781 {
5782 j->flags.dialtone = 0;
5783 j->flags.busytone = 0;
5784 j->flags.ringback = 0;
5785 ixj_set_tone_on(0x0001, j);
5786 ixj_set_tone_off(0x0000, j);
5787 ixj_play_tone(j, 0);
5788 j->tone_state = j->tone_cadence_state = 0;
5789 if (j->cadence_t) {
5790 kfree(j->cadence_t->ce);
5791 kfree(j->cadence_t);
5792 j->cadence_t = NULL;
5793 }
5794 }
5795 if (j->play_mode == -1 && j->rec_mode == -1)
5796 idle(j);
5797 if (j->play_mode != -1 && j->dsp.low == 0x20)
5798 ixj_play_start(j);
5799 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800 ixj_record_start(j);
5801 }
5802
5803 static void ixj_ringback(IXJ *j)
5804 {
5805 j->flags.busytone = 0;
5806 j->flags.dialtone = 0;
5807 j->flags.ringback = 1;
5808 ixj_set_tone_on(0x0FA0, j);
5809 ixj_set_tone_off(0x2EE0, j);
5810 ixj_play_tone(j, 26);
5811 }
5812
5813 static void ixj_testram(IXJ *j)
5814 {
5815 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820 ixj_cadence *lcp;
5821 IXJ_CADENCE_ELEMENT __user *cep;
5822 IXJ_CADENCE_ELEMENT *lcep;
5823 IXJ_TONE ti;
5824 int err;
5825
5826 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827 if (lcp == NULL)
5828 return -ENOMEM;
5829
5830 err = -EFAULT;
5831 if (copy_from_user(&lcp->elements_used,
5832 &cp->elements_used, sizeof(int)))
5833 goto out;
5834 if (copy_from_user(&lcp->termination,
5835 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836 goto out;
5837 if (get_user(cep, &cp->ce))
5838 goto out;
5839
5840 err = -EINVAL;
5841 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842 goto out;
5843
5844 err = -ENOMEM;
5845 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846 if (!lcep)
5847 goto out;
5848
5849 err = -EFAULT;
5850 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851 goto out1;
5852
5853 if (j->cadence_t) {
5854 kfree(j->cadence_t->ce);
5855 kfree(j->cadence_t);
5856 }
5857 lcp->ce = (void *) lcep;
5858 j->cadence_t = lcp;
5859 j->tone_cadence_state = 0;
5860 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868 ixj_init_tone(j, &ti);
5869 }
5870 ixj_play_tone(j, lcp->ce[0].index);
5871 return 1;
5872 out1:
5873 kfree(lcep);
5874 out:
5875 kfree(lcp);
5876 return err;
5877 }
5878
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881 IXJ_FILTER_CADENCE *lcp;
5882 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5883 if (lcp == NULL) {
5884 if(ixjdebug & 0x0001) {
5885 printk(KERN_INFO "Could not allocate memory for cadence\n");
5886 }
5887 return -ENOMEM;
5888 }
5889 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5890 if(ixjdebug & 0x0001) {
5891 printk(KERN_INFO "Could not copy cadence to kernel\n");
5892 }
5893 kfree(lcp);
5894 return -EFAULT;
5895 }
5896 if (lcp->filter > 5) {
5897 if(ixjdebug & 0x0001) {
5898 printk(KERN_INFO "Cadence out of range\n");
5899 }
5900 kfree(lcp);
5901 return -1;
5902 }
5903 j->cadence_f[lcp->filter].state = 0;
5904 j->cadence_f[lcp->filter].enable = lcp->enable;
5905 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5906 j->cadence_f[lcp->filter].on1 = lcp->on1;
5907 j->cadence_f[lcp->filter].on1min = 0;
5908 j->cadence_f[lcp->filter].on1max = 0;
5909 j->cadence_f[lcp->filter].off1 = lcp->off1;
5910 j->cadence_f[lcp->filter].off1min = 0;
5911 j->cadence_f[lcp->filter].off1max = 0;
5912 j->cadence_f[lcp->filter].on2 = lcp->on2;
5913 j->cadence_f[lcp->filter].on2min = 0;
5914 j->cadence_f[lcp->filter].on2max = 0;
5915 j->cadence_f[lcp->filter].off2 = lcp->off2;
5916 j->cadence_f[lcp->filter].off2min = 0;
5917 j->cadence_f[lcp->filter].off2max = 0;
5918 j->cadence_f[lcp->filter].on3 = lcp->on3;
5919 j->cadence_f[lcp->filter].on3min = 0;
5920 j->cadence_f[lcp->filter].on3max = 0;
5921 j->cadence_f[lcp->filter].off3 = lcp->off3;
5922 j->cadence_f[lcp->filter].off3min = 0;
5923 j->cadence_f[lcp->filter].off3max = 0;
5924 if(ixjdebug & 0x0002) {
5925 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5926 }
5927 kfree(lcp);
5928 return 0;
5929 }
5930
5931 static void add_caps(IXJ *j)
5932 {
5933 j->caps = 0;
5934 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5935 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5936 j->caplist[j->caps].captype = vendor;
5937 j->caplist[j->caps].handle = j->caps++;
5938 j->caplist[j->caps].captype = device;
5939 switch (j->cardtype) {
5940 case QTI_PHONEJACK:
5941 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5942 break;
5943 case QTI_LINEJACK:
5944 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5945 break;
5946 case QTI_PHONEJACK_LITE:
5947 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5948 break;
5949 case QTI_PHONEJACK_PCI:
5950 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5951 break;
5952 case QTI_PHONECARD:
5953 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5954 break;
5955 }
5956 j->caplist[j->caps].cap = j->cardtype;
5957 j->caplist[j->caps].handle = j->caps++;
5958 strcpy(j->caplist[j->caps].desc, "POTS");
5959 j->caplist[j->caps].captype = port;
5960 j->caplist[j->caps].cap = pots;
5961 j->caplist[j->caps].handle = j->caps++;
5962
5963 /* add devices that can do speaker/mic */
5964 switch (j->cardtype) {
5965 case QTI_PHONEJACK:
5966 case QTI_LINEJACK:
5967 case QTI_PHONEJACK_PCI:
5968 case QTI_PHONECARD:
5969 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5970 j->caplist[j->caps].captype = port;
5971 j->caplist[j->caps].cap = speaker;
5972 j->caplist[j->caps].handle = j->caps++;
5973 default:
5974 break;
5975 }
5976
5977 /* add devices that can do handset */
5978 switch (j->cardtype) {
5979 case QTI_PHONEJACK:
5980 strcpy(j->caplist[j->caps].desc, "HANDSET");
5981 j->caplist[j->caps].captype = port;
5982 j->caplist[j->caps].cap = handset;
5983 j->caplist[j->caps].handle = j->caps++;
5984 break;
5985 default:
5986 break;
5987 }
5988
5989 /* add devices that can do PSTN */
5990 switch (j->cardtype) {
5991 case QTI_LINEJACK:
5992 strcpy(j->caplist[j->caps].desc, "PSTN");
5993 j->caplist[j->caps].captype = port;
5994 j->caplist[j->caps].cap = pstn;
5995 j->caplist[j->caps].handle = j->caps++;
5996 break;
5997 default:
5998 break;
5999 }
6000
6001 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6002 strcpy(j->caplist[j->caps].desc, "ULAW");
6003 j->caplist[j->caps].captype = codec;
6004 j->caplist[j->caps].cap = ULAW;
6005 j->caplist[j->caps].handle = j->caps++;
6006
6007 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6008 j->caplist[j->caps].captype = codec;
6009 j->caplist[j->caps].cap = LINEAR16;
6010 j->caplist[j->caps].handle = j->caps++;
6011
6012 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6013 j->caplist[j->caps].captype = codec;
6014 j->caplist[j->caps].cap = LINEAR8;
6015 j->caplist[j->caps].handle = j->caps++;
6016
6017 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6018 j->caplist[j->caps].captype = codec;
6019 j->caplist[j->caps].cap = WSS;
6020 j->caplist[j->caps].handle = j->caps++;
6021
6022 /* software ALAW codec, made from ULAW */
6023 strcpy(j->caplist[j->caps].desc, "ALAW");
6024 j->caplist[j->caps].captype = codec;
6025 j->caplist[j->caps].cap = ALAW;
6026 j->caplist[j->caps].handle = j->caps++;
6027
6028 /* version 12 of the 8020 does the following codecs in a broken way */
6029 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6030 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6031 j->caplist[j->caps].captype = codec;
6032 j->caplist[j->caps].cap = G723_63;
6033 j->caplist[j->caps].handle = j->caps++;
6034
6035 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6036 j->caplist[j->caps].captype = codec;
6037 j->caplist[j->caps].cap = G723_53;
6038 j->caplist[j->caps].handle = j->caps++;
6039
6040 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6041 j->caplist[j->caps].captype = codec;
6042 j->caplist[j->caps].cap = TS48;
6043 j->caplist[j->caps].handle = j->caps++;
6044
6045 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6046 j->caplist[j->caps].captype = codec;
6047 j->caplist[j->caps].cap = TS41;
6048 j->caplist[j->caps].handle = j->caps++;
6049 }
6050
6051 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6052 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6053 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6054 j->caplist[j->caps].captype = codec;
6055 j->caplist[j->caps].cap = TS85;
6056 j->caplist[j->caps].handle = j->caps++;
6057 }
6058
6059 /* 8021 chips can do G728 */
6060 if (j->dsp.low == 0x21) {
6061 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6062 j->caplist[j->caps].captype = codec;
6063 j->caplist[j->caps].cap = G728;
6064 j->caplist[j->caps].handle = j->caps++;
6065 }
6066
6067 /* 8021/8022 chips can do G729 if loaded */
6068 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6070 j->caplist[j->caps].captype = codec;
6071 j->caplist[j->caps].cap = G729;
6072 j->caplist[j->caps].handle = j->caps++;
6073 }
6074 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6075 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6076 j->caplist[j->caps].captype = codec;
6077 j->caplist[j->caps].cap = G729B;
6078 j->caplist[j->caps].handle = j->caps++;
6079 }
6080 }
6081
6082 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6083 {
6084 int cnt;
6085 int retval = 0;
6086 for (cnt = 0; cnt < j->caps; cnt++) {
6087 if (pcreq->captype == j->caplist[cnt].captype
6088 && pcreq->cap == j->caplist[cnt].cap) {
6089 retval = 1;
6090 break;
6091 }
6092 }
6093 return retval;
6094 }
6095
6096 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6097 {
6098 IXJ_TONE ti;
6099 IXJ_FILTER jf;
6100 IXJ_FILTER_RAW jfr;
6101 void __user *argp = (void __user *)arg;
6102 struct inode *inode = file_p->f_path.dentry->d_inode;
6103 unsigned int minor = iminor(inode);
6104 unsigned int raise, mant;
6105 int board = NUM(inode);
6106
6107 IXJ *j = get_ixj(NUM(inode));
6108
6109 int retval = 0;
6110
6111 /*
6112 * Set up locks to ensure that only one process is talking to the DSP at a time.
6113 * This is necessary to keep the DSP from locking up.
6114 */
6115 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6116 schedule_timeout_interruptible(1);
6117 if (ixjdebug & 0x0040)
6118 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6119 if (minor >= IXJMAX) {
6120 clear_bit(board, &j->busyflags);
6121 return -ENODEV;
6122 }
6123 /*
6124 * Check ioctls only root can use.
6125 */
6126 if (!capable(CAP_SYS_ADMIN)) {
6127 switch (cmd) {
6128 case IXJCTL_TESTRAM:
6129 case IXJCTL_HZ:
6130 retval = -EPERM;
6131 }
6132 }
6133 switch (cmd) {
6134 case IXJCTL_TESTRAM:
6135 ixj_testram(j);
6136 retval = (j->ssr.high << 8) + j->ssr.low;
6137 break;
6138 case IXJCTL_CARDTYPE:
6139 retval = j->cardtype;
6140 break;
6141 case IXJCTL_SERIAL:
6142 retval = j->serial;
6143 break;
6144 case IXJCTL_VERSION:
6145 {
6146 char arg_str[100];
6147 snprintf(arg_str, sizeof(arg_str),
6148 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6149 IXJ_VER_MINOR, IXJ_BLD_VER);
6150 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6151 retval = -EFAULT;
6152 }
6153 break;
6154 case PHONE_RING_CADENCE:
6155 j->ring_cadence = arg;
6156 break;
6157 case IXJCTL_CIDCW:
6158 if(arg) {
6159 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6160 retval = -EFAULT;
6161 break;
6162 }
6163 } else {
6164 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6165 }
6166 ixj_write_cidcw(j);
6167 break;
6168 /* Binary compatbility */
6169 case OLD_PHONE_RING_START:
6170 arg = 0;
6171 /* Fall through */
6172 case PHONE_RING_START:
6173 if(arg) {
6174 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175 retval = -EFAULT;
6176 break;
6177 }
6178 ixj_write_cid(j);
6179 } else {
6180 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6181 }
6182 ixj_ring_start(j);
6183 break;
6184 case PHONE_RING_STOP:
6185 j->flags.cringing = 0;
6186 if(j->cadence_f[5].enable) {
6187 j->cadence_f[5].state = 0;
6188 }
6189 ixj_ring_off(j);
6190 break;
6191 case PHONE_RING:
6192 retval = ixj_ring(j);
6193 break;
6194 case PHONE_EXCEPTION:
6195 retval = j->ex.bytes;
6196 if(j->ex.bits.flash) {
6197 j->flash_end = 0;
6198 j->ex.bits.flash = 0;
6199 }
6200 j->ex.bits.pstn_ring = 0;
6201 j->ex.bits.caller_id = 0;
6202 j->ex.bits.pstn_wink = 0;
6203 j->ex.bits.f0 = 0;
6204 j->ex.bits.f1 = 0;
6205 j->ex.bits.f2 = 0;
6206 j->ex.bits.f3 = 0;
6207 j->ex.bits.fc0 = 0;
6208 j->ex.bits.fc1 = 0;
6209 j->ex.bits.fc2 = 0;
6210 j->ex.bits.fc3 = 0;
6211 j->ex.bits.reserved = 0;
6212 break;
6213 case PHONE_HOOKSTATE:
6214 j->ex.bits.hookstate = 0;
6215 retval = j->hookstate; //j->r_hook;
6216 break;
6217 case IXJCTL_SET_LED:
6218 LED_SetState(arg, j);
6219 break;
6220 case PHONE_FRAME:
6221 retval = set_base_frame(j, arg);
6222 break;
6223 case PHONE_REC_CODEC:
6224 retval = set_rec_codec(j, arg);
6225 break;
6226 case PHONE_VAD:
6227 ixj_vad(j, arg);
6228 break;
6229 case PHONE_REC_START:
6230 ixj_record_start(j);
6231 break;
6232 case PHONE_REC_STOP:
6233 ixj_record_stop(j);
6234 break;
6235 case PHONE_REC_DEPTH:
6236 set_rec_depth(j, arg);
6237 break;
6238 case PHONE_REC_VOLUME:
6239 if(arg == -1) {
6240 retval = get_rec_volume(j);
6241 }
6242 else {
6243 set_rec_volume(j, arg);
6244 retval = arg;
6245 }
6246 break;
6247 case PHONE_REC_VOLUME_LINEAR:
6248 if(arg == -1) {
6249 retval = get_rec_volume_linear(j);
6250 }
6251 else {
6252 set_rec_volume_linear(j, arg);
6253 retval = arg;
6254 }
6255 break;
6256 case IXJCTL_DTMF_PRESCALE:
6257 if(arg == -1) {
6258 retval = get_dtmf_prescale(j);
6259 }
6260 else {
6261 set_dtmf_prescale(j, arg);
6262 retval = arg;
6263 }
6264 break;
6265 case PHONE_REC_LEVEL:
6266 retval = get_rec_level(j);
6267 break;
6268 case IXJCTL_SC_RXG:
6269 retval = ixj_siadc(j, arg);
6270 break;
6271 case IXJCTL_SC_TXG:
6272 retval = ixj_sidac(j, arg);
6273 break;
6274 case IXJCTL_AEC_START:
6275 ixj_aec_start(j, arg);
6276 break;
6277 case IXJCTL_AEC_STOP:
6278 aec_stop(j);
6279 break;
6280 case IXJCTL_AEC_GET_LEVEL:
6281 retval = j->aec_level;
6282 break;
6283 case PHONE_PLAY_CODEC:
6284 retval = set_play_codec(j, arg);
6285 break;
6286 case PHONE_PLAY_START:
6287 retval = ixj_play_start(j);
6288 break;
6289 case PHONE_PLAY_STOP:
6290 ixj_play_stop(j);
6291 break;
6292 case PHONE_PLAY_DEPTH:
6293 set_play_depth(j, arg);
6294 break;
6295 case PHONE_PLAY_VOLUME:
6296 if(arg == -1) {
6297 retval = get_play_volume(j);
6298 }
6299 else {
6300 set_play_volume(j, arg);
6301 retval = arg;
6302 }
6303 break;
6304 case PHONE_PLAY_VOLUME_LINEAR:
6305 if(arg == -1) {
6306 retval = get_play_volume_linear(j);
6307 }
6308 else {
6309 set_play_volume_linear(j, arg);
6310 retval = arg;
6311 }
6312 break;
6313 case PHONE_PLAY_LEVEL:
6314 retval = get_play_level(j);
6315 break;
6316 case IXJCTL_DSP_TYPE:
6317 retval = (j->dsp.high << 8) + j->dsp.low;
6318 break;
6319 case IXJCTL_DSP_VERSION:
6320 retval = (j->ver.high << 8) + j->ver.low;
6321 break;
6322 case IXJCTL_HZ:
6323 hertz = arg;
6324 break;
6325 case IXJCTL_RATE:
6326 if (arg > hertz)
6327 retval = -1;
6328 else
6329 samplerate = arg;
6330 break;
6331 case IXJCTL_DRYBUFFER_READ:
6332 put_user(j->drybuffer, (unsigned long __user *) argp);
6333 break;
6334 case IXJCTL_DRYBUFFER_CLEAR:
6335 j->drybuffer = 0;
6336 break;
6337 case IXJCTL_FRAMES_READ:
6338 put_user(j->framesread, (unsigned long __user *) argp);
6339 break;
6340 case IXJCTL_FRAMES_WRITTEN:
6341 put_user(j->frameswritten, (unsigned long __user *) argp);
6342 break;
6343 case IXJCTL_READ_WAIT:
6344 put_user(j->read_wait, (unsigned long __user *) argp);
6345 break;
6346 case IXJCTL_WRITE_WAIT:
6347 put_user(j->write_wait, (unsigned long __user *) argp);
6348 break;
6349 case PHONE_MAXRINGS:
6350 j->maxrings = arg;
6351 break;
6352 case PHONE_SET_TONE_ON_TIME:
6353 ixj_set_tone_on(arg, j);
6354 break;
6355 case PHONE_SET_TONE_OFF_TIME:
6356 ixj_set_tone_off(arg, j);
6357 break;
6358 case PHONE_GET_TONE_ON_TIME:
6359 if (ixj_get_tone_on(j)) {
6360 retval = -1;
6361 } else {
6362 retval = (j->ssr.high << 8) + j->ssr.low;
6363 }
6364 break;
6365 case PHONE_GET_TONE_OFF_TIME:
6366 if (ixj_get_tone_off(j)) {
6367 retval = -1;
6368 } else {
6369 retval = (j->ssr.high << 8) + j->ssr.low;
6370 }
6371 break;
6372 case PHONE_PLAY_TONE:
6373 if (!j->tone_state)
6374 retval = ixj_play_tone(j, arg);
6375 else
6376 retval = -1;
6377 break;
6378 case PHONE_GET_TONE_STATE:
6379 retval = j->tone_state;
6380 break;
6381 case PHONE_DTMF_READY:
6382 retval = j->ex.bits.dtmf_ready;
6383 break;
6384 case PHONE_GET_DTMF:
6385 if (ixj_hookstate(j)) {
6386 if (j->dtmf_rp != j->dtmf_wp) {
6387 retval = j->dtmfbuffer[j->dtmf_rp];
6388 j->dtmf_rp++;
6389 if (j->dtmf_rp == 79)
6390 j->dtmf_rp = 0;
6391 if (j->dtmf_rp == j->dtmf_wp) {
6392 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6393 }
6394 }
6395 }
6396 break;
6397 case PHONE_GET_DTMF_ASCII:
6398 if (ixj_hookstate(j)) {
6399 if (j->dtmf_rp != j->dtmf_wp) {
6400 switch (j->dtmfbuffer[j->dtmf_rp]) {
6401 case 10:
6402 retval = 42; /* '*'; */
6403
6404 break;
6405 case 11:
6406 retval = 48; /*'0'; */
6407
6408 break;
6409 case 12:
6410 retval = 35; /*'#'; */
6411
6412 break;
6413 case 28:
6414 retval = 65; /*'A'; */
6415
6416 break;
6417 case 29:
6418 retval = 66; /*'B'; */
6419
6420 break;
6421 case 30:
6422 retval = 67; /*'C'; */
6423
6424 break;
6425 case 31:
6426 retval = 68; /*'D'; */
6427
6428 break;
6429 default:
6430 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6431 break;
6432 }
6433 j->dtmf_rp++;
6434 if (j->dtmf_rp == 79)
6435 j->dtmf_rp = 0;
6436 if(j->dtmf_rp == j->dtmf_wp)
6437 {
6438 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6439 }
6440 }
6441 }
6442 break;
6443 case PHONE_DTMF_OOB:
6444 j->flags.dtmf_oob = arg;
6445 break;
6446 case PHONE_DIALTONE:
6447 ixj_dialtone(j);
6448 break;
6449 case PHONE_BUSY:
6450 ixj_busytone(j);
6451 break;
6452 case PHONE_RINGBACK:
6453 ixj_ringback(j);
6454 break;
6455 case PHONE_WINK:
6456 if(j->cardtype == QTI_PHONEJACK)
6457 retval = -1;
6458 else
6459 retval = ixj_wink(j);
6460 break;
6461 case PHONE_CPT_STOP:
6462 ixj_cpt_stop(j);
6463 break;
6464 case PHONE_QUERY_CODEC:
6465 {
6466 struct phone_codec_data pd;
6467 int val;
6468 int proto_size[] = {
6469 -1,
6470 12, 10, 16, 9, 8, 48, 5,
6471 40, 40, 80, 40, 40, 6
6472 };
6473 if(copy_from_user(&pd, argp, sizeof(pd))) {
6474 retval = -EFAULT;
6475 break;
6476 }
6477 if(pd.type<1 || pd.type>13) {
6478 retval = -EPROTONOSUPPORT;
6479 break;
6480 }
6481 if(pd.type<G729)
6482 val=proto_size[pd.type];
6483 else switch(j->baseframe.low)
6484 {
6485 case 0xA0:val=2*proto_size[pd.type];break;
6486 case 0x50:val=proto_size[pd.type];break;
6487 default:val=proto_size[pd.type]*3;break;
6488 }
6489 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6490 if(copy_to_user(argp, &pd, sizeof(pd)))
6491 retval = -EFAULT;
6492 break;
6493 }
6494 case IXJCTL_DSP_IDLE:
6495 idle(j);
6496 break;
6497 case IXJCTL_MIXER:
6498 if ((arg & 0xff) == 0xff)
6499 retval = ixj_get_mixer(arg, j);
6500 else
6501 ixj_mixer(arg, j);
6502 break;
6503 case IXJCTL_DAA_COEFF_SET:
6504 switch (arg) {
6505 case DAA_US:
6506 DAA_Coeff_US(j);
6507 retval = ixj_daa_write(j);
6508 break;
6509 case DAA_UK:
6510 DAA_Coeff_UK(j);
6511 retval = ixj_daa_write(j);
6512 break;
6513 case DAA_FRANCE:
6514 DAA_Coeff_France(j);
6515 retval = ixj_daa_write(j);
6516 break;
6517 case DAA_GERMANY:
6518 DAA_Coeff_Germany(j);
6519 retval = ixj_daa_write(j);
6520 break;
6521 case DAA_AUSTRALIA:
6522 DAA_Coeff_Australia(j);
6523 retval = ixj_daa_write(j);
6524 break;
6525 case DAA_JAPAN:
6526 DAA_Coeff_Japan(j);
6527 retval = ixj_daa_write(j);
6528 break;
6529 default:
6530 retval = 1;
6531 break;
6532 }
6533 break;
6534 case IXJCTL_DAA_AGAIN:
6535 ixj_daa_cr4(j, arg | 0x02);
6536 break;
6537 case IXJCTL_PSTN_LINETEST:
6538 retval = ixj_linetest(j);
6539 break;
6540 case IXJCTL_VMWI:
6541 ixj_write_vmwi(j, arg);
6542 break;
6543 case IXJCTL_CID:
6544 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6545 retval = -EFAULT;
6546 j->ex.bits.caller_id = 0;
6547 break;
6548 case IXJCTL_WINK_DURATION:
6549 j->winktime = arg;
6550 break;
6551 case IXJCTL_PORT:
6552 if (arg)
6553 retval = ixj_set_port(j, arg);
6554 else
6555 retval = j->port;
6556 break;
6557 case IXJCTL_POTS_PSTN:
6558 retval = ixj_set_pots(j, arg);
6559 break;
6560 case PHONE_CAPABILITIES:
6561 add_caps(j);
6562 retval = j->caps;
6563 break;
6564 case PHONE_CAPABILITIES_LIST:
6565 add_caps(j);
6566 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6567 retval = -EFAULT;
6568 break;
6569 case PHONE_CAPABILITIES_CHECK:
6570 {
6571 struct phone_capability cap;
6572 if (copy_from_user(&cap, argp, sizeof(cap)))
6573 retval = -EFAULT;
6574 else {
6575 add_caps(j);
6576 retval = capabilities_check(j, &cap);
6577 }
6578 }
6579 break;
6580 case PHONE_PSTN_SET_STATE:
6581 daa_set_mode(j, arg);
6582 break;
6583 case PHONE_PSTN_GET_STATE:
6584 retval = j->daa_mode;
6585 j->ex.bits.pstn_ring = 0;
6586 break;
6587 case IXJCTL_SET_FILTER:
6588 if (copy_from_user(&jf, argp, sizeof(jf)))
6589 retval = -EFAULT;
6590 retval = ixj_init_filter(j, &jf);
6591 break;
6592 case IXJCTL_SET_FILTER_RAW:
6593 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6594 retval = -EFAULT;
6595 else
6596 retval = ixj_init_filter_raw(j, &jfr);
6597 break;
6598 case IXJCTL_GET_FILTER_HIST:
6599 if(arg<0||arg>3)
6600 retval = -EINVAL;
6601 else
6602 retval = j->filter_hist[arg];
6603 break;
6604 case IXJCTL_INIT_TONE:
6605 if (copy_from_user(&ti, argp, sizeof(ti)))
6606 retval = -EFAULT;
6607 else
6608 retval = ixj_init_tone(j, &ti);
6609 break;
6610 case IXJCTL_TONE_CADENCE:
6611 retval = ixj_build_cadence(j, argp);
6612 break;
6613 case IXJCTL_FILTER_CADENCE:
6614 retval = ixj_build_filter_cadence(j, argp);
6615 break;
6616 case IXJCTL_SIGCTL:
6617 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6618 retval = -EFAULT;
6619 break;
6620 }
6621 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6622 if(j->sigdef.event < 33) {
6623 raise = 1;
6624 for(mant = 0; mant < j->sigdef.event; mant++){
6625 raise *= 2;
6626 }
6627 if(j->sigdef.signal)
6628 j->ex_sig.bytes |= raise;
6629 else
6630 j->ex_sig.bytes &= (raise^0xffff);
6631 }
6632 break;
6633 case IXJCTL_INTERCOM_STOP:
6634 if(arg < 0 || arg >= IXJMAX)
6635 return -EINVAL;
6636 j->intercom = -1;
6637 ixj_record_stop(j);
6638 ixj_play_stop(j);
6639 idle(j);
6640 get_ixj(arg)->intercom = -1;
6641 ixj_record_stop(get_ixj(arg));
6642 ixj_play_stop(get_ixj(arg));
6643 idle(get_ixj(arg));
6644 break;
6645 case IXJCTL_INTERCOM_START:
6646 if(arg < 0 || arg >= IXJMAX)
6647 return -EINVAL;
6648 j->intercom = arg;
6649 ixj_record_start(j);
6650 ixj_play_start(j);
6651 get_ixj(arg)->intercom = board;
6652 ixj_play_start(get_ixj(arg));
6653 ixj_record_start(get_ixj(arg));
6654 break;
6655 }
6656 if (ixjdebug & 0x0040)
6657 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6658 clear_bit(board, &j->busyflags);
6659 return retval;
6660 }
6661
6662 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6663 {
6664 long ret;
6665 lock_kernel();
6666 ret = do_ixj_ioctl(file_p, cmd, arg);
6667 unlock_kernel();
6668 return ret;
6669 }
6670
6671 static int ixj_fasync(int fd, struct file *file_p, int mode)
6672 {
6673 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6674
6675 return fasync_helper(fd, file_p, mode, &j->async_queue);
6676 }
6677
6678 static const struct file_operations ixj_fops =
6679 {
6680 .owner = THIS_MODULE,
6681 .read = ixj_enhanced_read,
6682 .write = ixj_enhanced_write,
6683 .poll = ixj_poll,
6684 .unlocked_ioctl = ixj_ioctl,
6685 .release = ixj_release,
6686 .fasync = ixj_fasync
6687 };
6688
6689 static int ixj_linetest(IXJ *j)
6690 {
6691 j->flags.pstncheck = 1; /* Testing */
6692 j->flags.pstn_present = 0; /* Assume the line is not there */
6693
6694 daa_int_read(j); /*Clear DAA Interrupt flags */
6695 /* */
6696 /* Hold all relays in the normally de-energized position. */
6697 /* */
6698
6699 j->pld_slicw.bits.rly1 = 0;
6700 j->pld_slicw.bits.rly2 = 0;
6701 j->pld_slicw.bits.rly3 = 0;
6702 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6703 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6704
6705 outb_p(j->pld_scrw.byte, j->XILINXbase);
6706 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6707 if (j->pld_slicr.bits.potspstn) {
6708 j->flags.pots_pstn = 1;
6709 j->flags.pots_correct = 0;
6710 LED_SetState(0x4, j);
6711 } else {
6712 j->flags.pots_pstn = 0;
6713 j->pld_slicw.bits.rly1 = 0;
6714 j->pld_slicw.bits.rly2 = 0;
6715 j->pld_slicw.bits.rly3 = 1;
6716 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6717 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6718
6719 outb_p(j->pld_scrw.byte, j->XILINXbase);
6720 daa_set_mode(j, SOP_PU_CONVERSATION);
6721 msleep(1000);
6722 daa_int_read(j);
6723 daa_set_mode(j, SOP_PU_RESET);
6724 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6725 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6726 LED_SetState(0x4, j);
6727 j->pld_slicw.bits.rly3 = 0;
6728 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6729 } else {
6730 j->flags.pots_correct = 1;
6731 LED_SetState(0x8, j);
6732 j->pld_slicw.bits.rly1 = 1;
6733 j->pld_slicw.bits.rly2 = 0;
6734 j->pld_slicw.bits.rly3 = 0;
6735 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736 }
6737 }
6738 j->pld_slicw.bits.rly3 = 0;
6739 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6740 daa_set_mode(j, SOP_PU_CONVERSATION);
6741 msleep(1000);
6742 daa_int_read(j);
6743 daa_set_mode(j, SOP_PU_RESET);
6744 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6745 j->pstn_sleeptil = jiffies + (hertz / 4);
6746 j->flags.pstn_present = 1;
6747 } else {
6748 j->flags.pstn_present = 0;
6749 }
6750 if (j->flags.pstn_present) {
6751 if (j->flags.pots_correct) {
6752 LED_SetState(0xA, j);
6753 } else {
6754 LED_SetState(0x6, j);
6755 }
6756 } else {
6757 if (j->flags.pots_correct) {
6758 LED_SetState(0x9, j);
6759 } else {
6760 LED_SetState(0x5, j);
6761 }
6762 }
6763 j->flags.pstncheck = 0; /* Testing */
6764 return j->flags.pstn_present;
6765 }
6766
6767 static int ixj_selfprobe(IXJ *j)
6768 {
6769 unsigned short cmd;
6770 int cnt;
6771 BYTES bytes;
6772
6773 init_waitqueue_head(&j->poll_q);
6774 init_waitqueue_head(&j->read_q);
6775 init_waitqueue_head(&j->write_q);
6776
6777 while(atomic_read(&j->DSPWrite) > 0)
6778 atomic_dec(&j->DSPWrite);
6779 if (ixjdebug & 0x0002)
6780 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6781 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6782
6783 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6784 return -1;
6785 /* The read values of the SSR should be 0x00 for the IDLE command */
6786 if (j->ssr.low || j->ssr.high)
6787 return -1;
6788 if (ixjdebug & 0x0002)
6789 printk(KERN_INFO "Get Device ID Code\n");
6790 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6791 return -1;
6792 j->dsp.low = j->ssr.low;
6793 j->dsp.high = j->ssr.high;
6794 if (ixjdebug & 0x0002)
6795 printk(KERN_INFO "Get Device Version Code\n");
6796 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6797 return -1;
6798 j->ver.low = j->ssr.low;
6799 j->ver.high = j->ssr.high;
6800 if (!j->cardtype) {
6801 if (j->dsp.low == 0x21) {
6802 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6803 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6804 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6805 bytes.low = inb_p(j->XILINXbase + 0x02);
6806 if (bytes.low == bytes.high) /* Register is read only on */
6807 /* Internet PhoneJack Lite */
6808 {
6809 j->cardtype = QTI_PHONEJACK_LITE;
6810 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6811 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812 return -1;
6813 }
6814 j->pld_slicw.pcib.e1 = 1;
6815 outb_p(j->pld_slicw.byte, j->XILINXbase);
6816 } else {
6817 j->cardtype = QTI_LINEJACK;
6818
6819 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6820 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6821 return -1;
6822 }
6823 }
6824 } else if (j->dsp.low == 0x22) {
6825 j->cardtype = QTI_PHONEJACK_PCI;
6826 request_region(j->XILINXbase, 4, "ixj control");
6827 j->pld_slicw.pcib.e1 = 1;
6828 outb_p(j->pld_slicw.byte, j->XILINXbase);
6829 } else
6830 j->cardtype = QTI_PHONEJACK;
6831 } else {
6832 switch (j->cardtype) {
6833 case QTI_PHONEJACK:
6834 if (!j->dsp.low != 0x20) {
6835 j->dsp.high = 0x80;
6836 j->dsp.low = 0x20;
6837 ixj_WriteDSPCommand(0x3800, j);
6838 j->ver.low = j->ssr.low;
6839 j->ver.high = j->ssr.high;
6840 }
6841 break;
6842 case QTI_LINEJACK:
6843 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6844 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6845 return -1;
6846 }
6847 break;
6848 case QTI_PHONEJACK_LITE:
6849 case QTI_PHONEJACK_PCI:
6850 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6851 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6852 return -1;
6853 }
6854 j->pld_slicw.pcib.e1 = 1;
6855 outb_p(j->pld_slicw.byte, j->XILINXbase);
6856 break;
6857 case QTI_PHONECARD:
6858 break;
6859 }
6860 }
6861 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6862 if (ixjdebug & 0x0002)
6863 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6864 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6865 return -1;
6866 if (ixjdebug & 0x0002)
6867 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6868 if (j->cardtype == QTI_PHONEJACK) {
6869 cmd = 0x9FF2;
6870 } else {
6871 cmd = 0x9FF5;
6872 }
6873 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6874 return -1;
6875 } else {
6876 if (set_base_frame(j, 30) != 30)
6877 return -1;
6878 if (ixjdebug & 0x0002)
6879 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6880 if (j->cardtype == QTI_PHONECARD) {
6881 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6882 return -1;
6883 }
6884 if (j->cardtype == QTI_LINEJACK) {
6885 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6886 return -1;
6887 if (ixjdebug & 0x0002)
6888 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6889 j->pld_clock.byte = 0;
6890 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6891 }
6892 }
6893
6894 if (j->dsp.low == 0x20) {
6895 if (ixjdebug & 0x0002)
6896 printk(KERN_INFO "Configure GPIO pins\n");
6897 j->gpio.bytes.high = 0x09;
6898 /* bytes.low = 0xEF; 0xF7 */
6899 j->gpio.bits.gpio1 = 1;
6900 j->gpio.bits.gpio2 = 1;
6901 j->gpio.bits.gpio3 = 0;
6902 j->gpio.bits.gpio4 = 1;
6903 j->gpio.bits.gpio5 = 1;
6904 j->gpio.bits.gpio6 = 1;
6905 j->gpio.bits.gpio7 = 1;
6906 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6907 if (ixjdebug & 0x0002)
6908 printk(KERN_INFO "Enable SLIC\n");
6909 j->gpio.bytes.high = 0x0B;
6910 j->gpio.bytes.low = 0x00;
6911 j->gpio.bits.gpio1 = 0;
6912 j->gpio.bits.gpio2 = 1;
6913 j->gpio.bits.gpio5 = 0;
6914 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6915 j->port = PORT_POTS;
6916 } else {
6917 if (j->cardtype == QTI_LINEJACK) {
6918 LED_SetState(0x1, j);
6919 msleep(100);
6920 LED_SetState(0x2, j);
6921 msleep(100);
6922 LED_SetState(0x4, j);
6923 msleep(100);
6924 LED_SetState(0x8, j);
6925 msleep(100);
6926 LED_SetState(0x0, j);
6927 daa_get_version(j);
6928 if (ixjdebug & 0x0002)
6929 printk("Loading DAA Coefficients\n");
6930 DAA_Coeff_US(j);
6931 if (!ixj_daa_write(j)) {
6932 printk("DAA write failed on board %d\n", j->board);
6933 return -1;
6934 }
6935 if(!ixj_daa_cid_reset(j)) {
6936 printk("DAA CID reset failed on board %d\n", j->board);
6937 return -1;
6938 }
6939 j->flags.pots_correct = 0;
6940 j->flags.pstn_present = 0;
6941 ixj_linetest(j);
6942 if (j->flags.pots_correct) {
6943 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6944
6945 outb_p(j->pld_scrw.byte, j->XILINXbase);
6946 j->pld_slicw.bits.rly1 = 1;
6947 j->pld_slicw.bits.spken = 1;
6948 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6949 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6950 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6951 j->port = PORT_POTS;
6952 }
6953 ixj_set_port(j, PORT_PSTN);
6954 ixj_set_pots(j, 1);
6955 if (ixjdebug & 0x0002)
6956 printk(KERN_INFO "Enable Mixer\n");
6957 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6958 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6959
6960 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6961 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6962
6963 ixj_mixer(0x0480, j); /*FM Left mute */
6964 ixj_mixer(0x0580, j); /*FM Right mute */
6965
6966 ixj_mixer(0x0680, j); /*CD Left mute */
6967 ixj_mixer(0x0780, j); /*CD Right mute */
6968
6969 ixj_mixer(0x0880, j); /*Line Left mute */
6970 ixj_mixer(0x0980, j); /*Line Right mute */
6971
6972 ixj_mixer(0x0A80, j); /*Aux left mute */
6973 ixj_mixer(0x0B80, j); /*Aux right mute */
6974
6975 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6976 ixj_mixer(0x0D80, j); /*Mono2 mute */
6977
6978 ixj_mixer(0x0E80, j); /*Mic mute */
6979
6980 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6981
6982 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6983 ixj_mixer(0x110C, j);
6984
6985
6986 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6987 ixj_mixer(0x1401, j);
6988
6989 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6990 ixj_mixer(0x1501, j);
6991
6992 ixj_mixer(0x1700, j); /*Clock select */
6993
6994 ixj_mixer(0x1800, j); /*ADC input from mixer */
6995
6996 ixj_mixer(0x1901, j); /*Mic gain 30db */
6997
6998 if (ixjdebug & 0x0002)
6999 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7000 j->cadence_f[4].state = 0;
7001 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7002 j->cadence_f[4].off1 = 0;
7003 j->cadence_f[4].on2 = 0;
7004 j->cadence_f[4].off2 = 0;
7005 j->cadence_f[4].on3 = 0;
7006 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7007 j->pstn_last_rmr = jiffies;
7008
7009 } else {
7010 if (j->cardtype == QTI_PHONECARD) {
7011 ixj_WriteDSPCommand(0xCF07, j);
7012 ixj_WriteDSPCommand(0x00B0, j);
7013 ixj_set_port(j, PORT_SPEAKER);
7014 } else {
7015 ixj_set_port(j, PORT_POTS);
7016 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7017 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7018 }
7019 }
7020 }
7021
7022 j->intercom = -1;
7023 j->framesread = j->frameswritten = 0;
7024 j->read_wait = j->write_wait = 0;
7025 j->rxreadycheck = j->txreadycheck = 0;
7026
7027 /* initialise the DTMF prescale to a sensible value */
7028 if (j->cardtype == QTI_LINEJACK) {
7029 set_dtmf_prescale(j, 0x10);
7030 } else {
7031 set_dtmf_prescale(j, 0x40);
7032 }
7033 set_play_volume(j, 0x100);
7034 set_rec_volume(j, 0x100);
7035
7036 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7037 return -1;
7038 /* The read values of the SSR should be 0x00 for the IDLE command */
7039 if (j->ssr.low || j->ssr.high)
7040 return -1;
7041
7042 if (ixjdebug & 0x0002)
7043 printk(KERN_INFO "Enable Line Monitor\n");
7044
7045 if (ixjdebug & 0x0002)
7046 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7047
7048 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7049 return -1;
7050
7051 if (ixjdebug & 0x002)
7052 printk(KERN_INFO "Enable DTMF Detectors\n");
7053
7054 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7055 return -1;
7056
7057 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7058 return -1;
7059
7060 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7061
7062 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7063
7064 j->ex.bits.dtmf_ready = 0;
7065 j->dtmf_state = 0;
7066 j->dtmf_wp = j->dtmf_rp = 0;
7067 j->rec_mode = j->play_mode = -1;
7068 j->flags.ringing = 0;
7069 j->maxrings = MAXRINGS;
7070 j->ring_cadence = USA_RING_CADENCE;
7071 j->drybuffer = 0;
7072 j->winktime = 320;
7073 j->flags.dtmf_oob = 0;
7074 for (cnt = 0; cnt < 4; cnt++)
7075 j->cadence_f[cnt].enable = 0;
7076 /* must be a device on the specified address */
7077 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7078
7079 /* Set up the default signals for events */
7080 for (cnt = 0; cnt < 35; cnt++)
7081 j->ixj_signals[cnt] = SIGIO;
7082
7083 /* Set the excetion signal enable flags */
7084 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7085 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 =
7086 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;
7087 #ifdef IXJ_DYN_ALLOC
7088 j->fskdata = NULL;
7089 #endif
7090 j->fskdcnt = 0;
7091 j->cidcw_wait = 0;
7092
7093 /* Register with the Telephony for Linux subsystem */
7094 j->p.f_op = &ixj_fops;
7095 j->p.open = ixj_open;
7096 j->p.board = j->board;
7097 phone_register_device(&j->p, PHONE_UNIT_ANY);
7098
7099 ixj_init_timer(j);
7100 ixj_add_timer(j);
7101 return 0;
7102 }
7103
7104 /*
7105 * Exported service for pcmcia card handling
7106 */
7107
7108 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7109 {
7110 IXJ *j = ixj_alloc();
7111
7112 j->board = 0;
7113
7114 j->DSPbase = dsp;
7115 j->XILINXbase = xilinx;
7116 j->cardtype = QTI_PHONECARD;
7117 ixj_selfprobe(j);
7118 return j;
7119 }
7120
7121 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7122
7123 static int ixj_get_status_proc(char *buf)
7124 {
7125 int len;
7126 int cnt;
7127 IXJ *j;
7128 len = 0;
7129 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7130 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7131 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7132 len += sprintf(buf + len, "\nUsing old telephony API");
7133 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7134
7135 for (cnt = 0; cnt < IXJMAX; cnt++) {
7136 j = get_ixj(cnt);
7137 if(j==NULL)
7138 continue;
7139 if (j->DSPbase) {
7140 len += sprintf(buf + len, "\nCard Num %d", cnt);
7141 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7142 if (j->cardtype != QTI_PHONEJACK)
7143 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7144 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7145 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7146 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7147 switch (j->cardtype) {
7148 case (QTI_PHONEJACK):
7149 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7150 break;
7151 case (QTI_LINEJACK):
7152 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7153 if (j->flags.g729_loaded)
7154 len += sprintf(buf + len, " w/G.729 A/B");
7155 len += sprintf(buf + len, " Country = %d", j->daa_country);
7156 break;
7157 case (QTI_PHONEJACK_LITE):
7158 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7159 if (j->flags.g729_loaded)
7160 len += sprintf(buf + len, " w/G.729 A/B");
7161 break;
7162 case (QTI_PHONEJACK_PCI):
7163 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7164 if (j->flags.g729_loaded)
7165 len += sprintf(buf + len, " w/G.729 A/B");
7166 break;
7167 case (QTI_PHONECARD):
7168 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7169 if (j->flags.g729_loaded)
7170 len += sprintf(buf + len, " w/G.729 A/B");
7171 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7172 if (!j->pccr1.bits.drf)
7173 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7174 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7175 break;
7176 default:
7177 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7178 break;
7179 }
7180 len += sprintf(buf + len, "\nReaders %d", j->readers);
7181 len += sprintf(buf + len, "\nWriters %d", j->writers);
7182 add_caps(j);
7183 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7184 if (j->dsp.low != 0x20)
7185 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7186 if (j->flags.cidsent)
7187 len += sprintf(buf + len, "\nCaller ID data sent");
7188 else
7189 len += sprintf(buf + len, "\nCaller ID data not sent");
7190
7191 len += sprintf(buf + len, "\nPlay CODEC ");
7192 switch (j->play_codec) {
7193 case G723_63:
7194 len += sprintf(buf + len, "G.723.1 6.3");
7195 break;
7196 case G723_53:
7197 len += sprintf(buf + len, "G.723.1 5.3");
7198 break;
7199 case TS85:
7200 len += sprintf(buf + len, "TrueSpeech 8.5");
7201 break;
7202 case TS48:
7203 len += sprintf(buf + len, "TrueSpeech 4.8");
7204 break;
7205 case TS41:
7206 len += sprintf(buf + len, "TrueSpeech 4.1");
7207 break;
7208 case G728:
7209 len += sprintf(buf + len, "G.728");
7210 break;
7211 case G729:
7212 len += sprintf(buf + len, "G.729");
7213 break;
7214 case G729B:
7215 len += sprintf(buf + len, "G.729B");
7216 break;
7217 case ULAW:
7218 len += sprintf(buf + len, "uLaw");
7219 break;
7220 case ALAW:
7221 len += sprintf(buf + len, "aLaw");
7222 break;
7223 case LINEAR16:
7224 len += sprintf(buf + len, "16 bit Linear");
7225 break;
7226 case LINEAR8:
7227 len += sprintf(buf + len, "8 bit Linear");
7228 break;
7229 case WSS:
7230 len += sprintf(buf + len, "Windows Sound System");
7231 break;
7232 default:
7233 len += sprintf(buf + len, "NO CODEC CHOSEN");
7234 break;
7235 }
7236 len += sprintf(buf + len, "\nRecord CODEC ");
7237 switch (j->rec_codec) {
7238 case G723_63:
7239 len += sprintf(buf + len, "G.723.1 6.3");
7240 break;
7241 case G723_53:
7242 len += sprintf(buf + len, "G.723.1 5.3");
7243 break;
7244 case TS85:
7245 len += sprintf(buf + len, "TrueSpeech 8.5");
7246 break;
7247 case TS48:
7248 len += sprintf(buf + len, "TrueSpeech 4.8");
7249 break;
7250 case TS41:
7251 len += sprintf(buf + len, "TrueSpeech 4.1");
7252 break;
7253 case G728:
7254 len += sprintf(buf + len, "G.728");
7255 break;
7256 case G729:
7257 len += sprintf(buf + len, "G.729");
7258 break;
7259 case G729B:
7260 len += sprintf(buf + len, "G.729B");
7261 break;
7262 case ULAW:
7263 len += sprintf(buf + len, "uLaw");
7264 break;
7265 case ALAW:
7266 len += sprintf(buf + len, "aLaw");
7267 break;
7268 case LINEAR16:
7269 len += sprintf(buf + len, "16 bit Linear");
7270 break;
7271 case LINEAR8:
7272 len += sprintf(buf + len, "8 bit Linear");
7273 break;
7274 case WSS:
7275 len += sprintf(buf + len, "Windows Sound System");
7276 break;
7277 default:
7278 len += sprintf(buf + len, "NO CODEC CHOSEN");
7279 break;
7280 }
7281 len += sprintf(buf + len, "\nAEC ");
7282 switch (j->aec_level) {
7283 case AEC_OFF:
7284 len += sprintf(buf + len, "Off");
7285 break;
7286 case AEC_LOW:
7287 len += sprintf(buf + len, "Low");
7288 break;
7289 case AEC_MED:
7290 len += sprintf(buf + len, "Med");
7291 break;
7292 case AEC_HIGH:
7293 len += sprintf(buf + len, "High");
7294 break;
7295 case AEC_AUTO:
7296 len += sprintf(buf + len, "Auto");
7297 break;
7298 case AEC_AGC:
7299 len += sprintf(buf + len, "AEC/AGC");
7300 break;
7301 default:
7302 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7303 break;
7304 }
7305
7306 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7307 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7308 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7309
7310 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7311
7312 if (j->cardtype == QTI_LINEJACK) {
7313 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7314 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7315 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7316 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7317 switch (j->daa_mode) {
7318 case SOP_PU_SLEEP:
7319 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7320 break;
7321 case SOP_PU_RINGING:
7322 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7323 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7324 break;
7325 case SOP_PU_CONVERSATION:
7326 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7327 break;
7328 case SOP_PU_PULSEDIALING:
7329 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7330 break;
7331 }
7332 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7333 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7334 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7335 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7336 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7337 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7338 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7339 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7340 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7341 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7342 }
7343 switch (j->port) {
7344 case PORT_POTS:
7345 len += sprintf(buf + len, "\nPort POTS");
7346 break;
7347 case PORT_PSTN:
7348 len += sprintf(buf + len, "\nPort PSTN");
7349 break;
7350 case PORT_SPEAKER:
7351 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7352 break;
7353 case PORT_HANDSET:
7354 len += sprintf(buf + len, "\nPort HANDSET");
7355 break;
7356 }
7357 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7358 len += sprintf(buf + len, "\nSLIC state ");
7359 switch (SLIC_GetState(j)) {
7360 case PLD_SLIC_STATE_OC:
7361 len += sprintf(buf + len, "OC");
7362 break;
7363 case PLD_SLIC_STATE_RINGING:
7364 len += sprintf(buf + len, "RINGING");
7365 break;
7366 case PLD_SLIC_STATE_ACTIVE:
7367 len += sprintf(buf + len, "ACTIVE");
7368 break;
7369 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7370 len += sprintf(buf + len, "OHT");
7371 break;
7372 case PLD_SLIC_STATE_TIPOPEN:
7373 len += sprintf(buf + len, "TIPOPEN");
7374 break;
7375 case PLD_SLIC_STATE_STANDBY:
7376 len += sprintf(buf + len, "STANDBY");
7377 break;
7378 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7379 len += sprintf(buf + len, "APR");
7380 break;
7381 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7382 len += sprintf(buf + len, "OHTPR");
7383 break;
7384 default:
7385 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7386 break;
7387 }
7388 }
7389 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7390 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7391 #ifdef PERFMON_STATS
7392 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7393 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7394 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7395 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7396 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7397 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7398 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7399 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7400 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7401 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7402 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7403 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7404 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7405 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7406
7407 #endif
7408 len += sprintf(buf + len, "\n");
7409 }
7410 }
7411 return len;
7412 }
7413
7414 static int ixj_read_proc(char *page, char **start, off_t off,
7415 int count, int *eof, void *data)
7416 {
7417 int len = ixj_get_status_proc(page);
7418 if (len <= off+count) *eof = 1;
7419 *start = page + off;
7420 len -= off;
7421 if (len>count) len = count;
7422 if (len<0) len = 0;
7423 return len;
7424 }
7425
7426
7427 static void cleanup(void)
7428 {
7429 int cnt;
7430 IXJ *j;
7431
7432 for (cnt = 0; cnt < IXJMAX; cnt++) {
7433 j = get_ixj(cnt);
7434 if(j != NULL && j->DSPbase) {
7435 if (ixjdebug & 0x0002)
7436 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7437 del_timer(&j->timer);
7438 if (j->cardtype == QTI_LINEJACK) {
7439 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7440
7441 outb_p(j->pld_scrw.byte, j->XILINXbase);
7442 j->pld_slicw.bits.rly1 = 0;
7443 j->pld_slicw.bits.rly2 = 0;
7444 j->pld_slicw.bits.rly3 = 0;
7445 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7446 LED_SetState(0x0, j);
7447 if (ixjdebug & 0x0002)
7448 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449 release_region(j->XILINXbase, 8);
7450 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7451 if (ixjdebug & 0x0002)
7452 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7453 release_region(j->XILINXbase, 4);
7454 }
7455 kfree(j->read_buffer);
7456 kfree(j->write_buffer);
7457 if (j->dev)
7458 pnp_device_detach(j->dev);
7459 if (ixjdebug & 0x0002)
7460 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7461 phone_unregister_device(&j->p);
7462 if (ixjdebug & 0x0002)
7463 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7464 release_region(j->DSPbase, 16);
7465 #ifdef IXJ_DYN_ALLOC
7466 if (ixjdebug & 0x0002)
7467 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7468 kfree(j);
7469 ixj[cnt] = NULL;
7470 #endif
7471 }
7472 }
7473 if (ixjdebug & 0x0002)
7474 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7475 remove_proc_entry ("ixj", NULL);
7476 }
7477
7478 /* Typedefs */
7479 typedef struct {
7480 BYTE length;
7481 DWORD bits;
7482 } DATABLOCK;
7483
7484 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7485 {
7486 lastLCC = lastLCC & 0xfb;
7487 lastLCC = lastLCC | (byData ? 4 : 0);
7488 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7489
7490 mdelay(1);
7491 lastLCC = lastLCC | 0x01;
7492 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7493
7494 byData = byData << 1;
7495 lastLCC = lastLCC & 0xfe;
7496 mdelay(1);
7497 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7498
7499 }
7500
7501 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7502 {
7503 mdelay(1);
7504 lastLCC = lastLCC | 0x01;
7505 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7506
7507 lastLCC = lastLCC & 0xfe;
7508 mdelay(1);
7509 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7510
7511 return ((inb(wEEPROMAddress) >> 3) & 1);
7512 }
7513
7514 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7515 {
7516 BYTE lastLCC;
7517 WORD wEEPROMAddress = wAddress + 3;
7518 DWORD i;
7519 BYTE byResult;
7520 *pwResult = 0;
7521 lastLCC = inb(wEEPROMAddress);
7522 lastLCC = lastLCC | 0x02;
7523 lastLCC = lastLCC & 0xfe;
7524 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7525
7526 mdelay(1); /* delay */
7527
7528 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7529 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7530 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7531 for (i = 0; i < 8; i++) {
7532 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7533 wLoc <<= 1;
7534 }
7535
7536 for (i = 0; i < 16; i++) {
7537 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7538 *pwResult = (*pwResult << 1) | byResult;
7539 }
7540
7541 mdelay(1); /* another delay */
7542
7543 lastLCC = lastLCC & 0xfd;
7544 outb(lastLCC, wEEPROMAddress); /* negate CS */
7545
7546 return 0;
7547 }
7548
7549 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7550 {
7551 WORD wLo, wHi;
7552 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7553 return 0;
7554 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7555 return 0;
7556 return (((DWORD) wHi << 16) | wLo);
7557 }
7558
7559 static int dspio[IXJMAX + 1] =
7560 {
7561 0,
7562 };
7563 static int xio[IXJMAX + 1] =
7564 {
7565 0,
7566 };
7567
7568 module_param_array(dspio, int, NULL, 0);
7569 module_param_array(xio, int, NULL, 0);
7570 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7571 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7572 MODULE_LICENSE("GPL");
7573
7574 static void __exit ixj_exit(void)
7575 {
7576 cleanup();
7577 }
7578
7579 static IXJ *new_ixj(unsigned long port)
7580 {
7581 IXJ *res;
7582 if (!request_region(port, 16, "ixj DSP")) {
7583 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7584 return NULL;
7585 }
7586 res = ixj_alloc();
7587 if (!res) {
7588 release_region(port, 16);
7589 printk(KERN_INFO "ixj: out of memory\n");
7590 return NULL;
7591 }
7592 res->DSPbase = port;
7593 return res;
7594 }
7595
7596 static int __init ixj_probe_isapnp(int *cnt)
7597 {
7598 int probe = 0;
7599 int func = 0x110;
7600 struct pnp_dev *dev = NULL, *old_dev = NULL;
7601
7602 while (1) {
7603 do {
7604 IXJ *j;
7605 int result;
7606
7607 old_dev = dev;
7608 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7609 ISAPNP_FUNCTION(func), old_dev);
7610 if (!dev || !dev->card)
7611 break;
7612 result = pnp_device_attach(dev);
7613 if (result < 0) {
7614 printk("pnp attach failed %d \n", result);
7615 break;
7616 }
7617 if (pnp_activate_dev(dev) < 0) {
7618 printk("pnp activate failed (out of resources?)\n");
7619 pnp_device_detach(dev);
7620 return -ENOMEM;
7621 }
7622
7623 if (!pnp_port_valid(dev, 0)) {
7624 pnp_device_detach(dev);
7625 return -ENODEV;
7626 }
7627
7628 j = new_ixj(pnp_port_start(dev, 0));
7629 if (!j)
7630 break;
7631
7632 if (func != 0x110)
7633 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7634
7635 switch (func) {
7636 case (0x110):
7637 j->cardtype = QTI_PHONEJACK;
7638 break;
7639 case (0x310):
7640 j->cardtype = QTI_LINEJACK;
7641 break;
7642 case (0x410):
7643 j->cardtype = QTI_PHONEJACK_LITE;
7644 break;
7645 }
7646 j->board = *cnt;
7647 probe = ixj_selfprobe(j);
7648 if(!probe) {
7649 j->serial = dev->card->serial;
7650 j->dev = dev;
7651 switch (func) {
7652 case 0x110:
7653 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7654 break;
7655 case 0x310:
7656 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7657 break;
7658 case 0x410:
7659 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7660 break;
7661 }
7662 }
7663 ++*cnt;
7664 } while (dev);
7665 if (func == 0x410)
7666 break;
7667 if (func == 0x310)
7668 func = 0x410;
7669 if (func == 0x110)
7670 func = 0x310;
7671 dev = NULL;
7672 }
7673 return probe;
7674 }
7675
7676 static int __init ixj_probe_isa(int *cnt)
7677 {
7678 int i, probe;
7679
7680 /* Use passed parameters for older kernels without PnP */
7681 for (i = 0; i < IXJMAX; i++) {
7682 if (dspio[i]) {
7683 IXJ *j = new_ixj(dspio[i]);
7684
7685 if (!j)
7686 break;
7687
7688 j->XILINXbase = xio[i];
7689 j->cardtype = 0;
7690
7691 j->board = *cnt;
7692 probe = ixj_selfprobe(j);
7693 j->dev = NULL;
7694 ++*cnt;
7695 }
7696 }
7697 return 0;
7698 }
7699
7700 static int __init ixj_probe_pci(int *cnt)
7701 {
7702 struct pci_dev *pci = NULL;
7703 int i, probe = 0;
7704 IXJ *j = NULL;
7705
7706 for (i = 0; i < IXJMAX - *cnt; i++) {
7707 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7708 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7709 if (!pci)
7710 break;
7711
7712 if (pci_enable_device(pci))
7713 break;
7714 j = new_ixj(pci_resource_start(pci, 0));
7715 if (!j)
7716 break;
7717
7718 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7719 j->XILINXbase = j->DSPbase + 0x10;
7720 j->cardtype = QTI_PHONEJACK_PCI;
7721 j->board = *cnt;
7722 probe = ixj_selfprobe(j);
7723 if (!probe)
7724 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7725 ++*cnt;
7726 }
7727 pci_dev_put(pci);
7728 return probe;
7729 }
7730
7731 static int __init ixj_init(void)
7732 {
7733 int cnt = 0;
7734 int probe = 0;
7735
7736 cnt = 0;
7737
7738 /* These might be no-ops, see above. */
7739 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7740 return probe;
7741 }
7742 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7743 return probe;
7744 }
7745 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7746 return probe;
7747 }
7748 printk(KERN_INFO "ixj driver initialized.\n");
7749 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7750 return probe;
7751 }
7752
7753 module_init(ixj_init);
7754 module_exit(ixj_exit);
7755
7756 static void DAA_Coeff_US(IXJ *j)
7757 {
7758 int i;
7759
7760 j->daa_country = DAA_US;
7761 /*----------------------------------------------- */
7762 /* CAO */
7763 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7764 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7765 }
7766
7767 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7776 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7778 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7779 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7780 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7781 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7782 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7783 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7784 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7785 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7794 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7796 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7797 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7798 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7799 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7800 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7801 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7802 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7803 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7804 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7805 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7806 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7807 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7808 /* Bytes for AR-filter (09): 52,D3,11,42 */
7809 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7810 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7811 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7812 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7813 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7822 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7831 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7833 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7834 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7835 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7836 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7837 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7838 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7839 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7840 /* ; (10K, 0.68uF) */
7841 /* */
7842 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7851 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7853 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7854 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7855 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7856 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7857 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7858 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7859 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7860
7861 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7862 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7863 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7864 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7865 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7866
7867 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7868 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7869 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7870 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7871 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7872 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7876 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7877 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7878 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7879 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7880 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7881 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7884 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7885 /* */
7886 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7887 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7888 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7889 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7890 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7891
7892 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7901 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7903 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7904 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7905 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7906 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7907 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7908 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7909 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7910 /* */
7911 /* ;CR Registers */
7912 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7914 /* Config. Reg. 1 (dialing) (cr1):05 */
7915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7916 /* Config. Reg. 2 (caller ID) (cr2):04 */
7917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7918 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7919 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7920 /* Config. Reg. 4 (analog gain) (cr4):02 */
7921 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7922 /* Config. Reg. 5 (Version) (cr5):02 */
7923 /* Config. Reg. 6 (Reserved) (cr6):00 */
7924 /* Config. Reg. 7 (Reserved) (cr7):00 */
7925 /* */
7926 /* ;xr Registers */
7927 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7928
7929 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7930 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7931
7932 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7933 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7934 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7935 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7936 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7937 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7938
7939 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7940 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7941 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7942 /* Ext. Reg. 6 (Power State) (xr6):00 */
7943 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7944 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7945 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7946 /* */
7947 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7948 /* 12,33,5A,C3 ; 770 Hz */
7949 /* 13,3C,5B,32 ; 852 Hz */
7950 /* 1D,1B,5C,CC ; 941 Hz */
7951
7952 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7953 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7954 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7956 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7957 /* EC,1D,52,22 ; 1336 Hz */
7958 /* AA,AC,51,D2 ; 1477 Hz */
7959 /* 9B,3B,51,25 ; 1633 Hz */
7960 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7961 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7962 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7963 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7964 }
7965
7966 static void DAA_Coeff_UK(IXJ *j)
7967 {
7968 int i;
7969
7970 j->daa_country = DAA_UK;
7971 /*----------------------------------------------- */
7972 /* CAO */
7973 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7974 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7975 }
7976
7977 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7986 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7988 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7989 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7990 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7991 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7992 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7993 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7994 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7995 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8004 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8006 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8007 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8008 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8009 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8010 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8011 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8012 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8013 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8014 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8015 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8016 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8017 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8018 /* Bytes for AR-filter (09): E2,27,10,D6 */
8019 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8020 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8021 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8022 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8023 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8032 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8041 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8043 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8044 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8045 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8046 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8047 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8048 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8049 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8050 /* ; idle */
8051 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8060 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8062 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8063 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8064 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8065 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8066 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8067 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8068 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8069 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8070 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8071 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8072 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8073 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8074 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8083 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8085 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8086 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8087 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8088 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8089 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8090 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8091 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8092 /* ;CR Registers */
8093 /* Config. Reg. 0 (filters) (cr0):FF */
8094 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8095 /* Config. Reg. 1 (dialing) (cr1):05 */
8096 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8097 /* Config. Reg. 2 (caller ID) (cr2):04 */
8098 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8099 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8100 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8101 /* Config. Reg. 4 (analog gain) (cr4):02 */
8102 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8103 /* Config. Reg. 5 (Version) (cr5):02 */
8104 /* Config. Reg. 6 (Reserved) (cr6):00 */
8105 /* Config. Reg. 7 (Reserved) (cr7):00 */
8106 /* ;xr Registers */
8107 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8108
8109 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8110 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8111
8112 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8113 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8114
8115 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8116 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8117 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8118 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8119 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8120 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8121 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8122 /* Ext. Reg. 6 (Power State) (xr6):00 */
8123 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8124 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8125 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8126 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8127 /* 12,33,5A,C3 ; 770 Hz */
8128 /* 13,3C,5B,32 ; 852 Hz */
8129 /* 1D,1B,5C,CC ; 941 Hz */
8130
8131 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8132 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8133 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8135 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8136 /* EC,1D,52,22 ; 1336 Hz */
8137 /* AA,AC,51,D2 ; 1477 Hz */
8138 /* 9B,3B,51,25 ; 1633 Hz */
8139 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8140 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8141 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8142 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8143 }
8144
8145
8146 static void DAA_Coeff_France(IXJ *j)
8147 {
8148 int i;
8149
8150 j->daa_country = DAA_FRANCE;
8151 /*----------------------------------------------- */
8152 /* CAO */
8153 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8154 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8155 }
8156
8157 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8166 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8168 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8169 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8170 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8171 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8172 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8173 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8174 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8175 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8184 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8186 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8187 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8188 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8189 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8190 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8191 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8192 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8193 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8194 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8195 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8196 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8197 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8198 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8199 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8200 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8201 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8202 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8203 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8212 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8221 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8223 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8224 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8225 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8226 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8227 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8228 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8229 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8230 /* ; idle */
8231 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8240 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8242 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8243 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8244 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8245 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8246 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8247 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8248 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8249 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8250 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8251 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8252 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8253 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8254 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8263 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8265 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8266 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8267 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8268 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8269 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8270 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8271 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8272 /* ;CR Registers */
8273 /* Config. Reg. 0 (filters) (cr0):FF */
8274 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8275 /* Config. Reg. 1 (dialing) (cr1):05 */
8276 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8277 /* Config. Reg. 2 (caller ID) (cr2):04 */
8278 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8279 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8280 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8281 /* Config. Reg. 4 (analog gain) (cr4):02 */
8282 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8283 /* Config. Reg. 5 (Version) (cr5):02 */
8284 /* Config. Reg. 6 (Reserved) (cr6):00 */
8285 /* Config. Reg. 7 (Reserved) (cr7):00 */
8286 /* ;xr Registers */
8287 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8288
8289 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8290 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8291
8292 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8293 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8294
8295 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8296 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8297 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8298 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8299 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8300 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8301 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8302 /* Ext. Reg. 6 (Power State) (xr6):00 */
8303 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8304 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8305 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8306 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8307 /* 12,33,5A,C3 ; 770 Hz */
8308 /* 13,3C,5B,32 ; 852 Hz */
8309 /* 1D,1B,5C,CC ; 941 Hz */
8310
8311 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8312 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8313 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8315 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8316 /* EC,1D,52,22 ; 1336 Hz */
8317 /* AA,AC,51,D2 ; 1477 Hz */
8318 /* 9B,3B,51,25 ; 1633 Hz */
8319 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8320 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8321 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8322 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8323 }
8324
8325
8326 static void DAA_Coeff_Germany(IXJ *j)
8327 {
8328 int i;
8329
8330 j->daa_country = DAA_GERMANY;
8331 /*----------------------------------------------- */
8332 /* CAO */
8333 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8334 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8335 }
8336
8337 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8346 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8348 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8349 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8350 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8351 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8352 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8353 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8354 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8355 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8364 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8366 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8367 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8368 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8369 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8370 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8371 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8372 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8373 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8374 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8375 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8376 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8377 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8378 /* Bytes for AR-filter (09): 72,42,13,4B */
8379 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8380 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8381 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8382 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8383 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8392 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8401 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8403 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8404 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8405 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8406 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8407 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8408 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8409 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8410 /* ; (10K, 0.68uF) */
8411 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8420 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8422 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8423 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8424 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8425 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8426 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8427 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8428 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8429 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8430 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8431 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8432 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8433 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8434 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8443 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8445 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8446 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8447 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8448 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8449 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8450 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8451 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8452 /* ;CR Registers */
8453 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8454 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8455 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8456 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8457 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8458 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8459 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8460 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8461 /* Config. Reg. 4 (analog gain) (cr4):02 */
8462 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8463 /* Config. Reg. 5 (Version) (cr5):02 */
8464 /* Config. Reg. 6 (Reserved) (cr6):00 */
8465 /* Config. Reg. 7 (Reserved) (cr7):00 */
8466 /* ;xr Registers */
8467 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8468
8469 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8470 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8471
8472 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8473 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8474
8475 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8476 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8477 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8478 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8479 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8480 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8481 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8482 /* Ext. Reg. 6 (Power State) (xr6):00 */
8483 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8484 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8485 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8486 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8487 /* 12,33,5A,C3 ; 770 Hz */
8488 /* 13,3C,5B,32 ; 852 Hz */
8489 /* 1D,1B,5C,CC ; 941 Hz */
8490
8491 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8492 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8493 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8495 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8496 /* EC,1D,52,22 ; 1336 Hz */
8497 /* AA,AC,51,D2 ; 1477 Hz */
8498 /* 9B,3B,51,25 ; 1633 Hz */
8499 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8500 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8501 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8502 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8503 }
8504
8505
8506 static void DAA_Coeff_Australia(IXJ *j)
8507 {
8508 int i;
8509
8510 j->daa_country = DAA_AUSTRALIA;
8511 /*----------------------------------------------- */
8512 /* CAO */
8513 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8514 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8515 }
8516
8517 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8526 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8528 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8529 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8530 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8531 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8532 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8533 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8534 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8535 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8544 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8546 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8547 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8548 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8549 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8550 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8551 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8552 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8553 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8554 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8555 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8556 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8557 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8558 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8559 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8560 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8561 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8562 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8563 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8572 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8581 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8583 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8584 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8585 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8586 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8587 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8588 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8589 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8590 /* ; idle */
8591 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8600 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8602 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8603 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8604 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8605 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8606 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8607 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8608 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8609 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8610 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8611 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8612 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8613 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8614 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8623 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8625 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8626 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8627 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8628 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8629 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8630 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8631 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8632 /* ;CR Registers */
8633 /* Config. Reg. 0 (filters) (cr0):FF */
8634 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8635 /* Config. Reg. 1 (dialing) (cr1):05 */
8636 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8637 /* Config. Reg. 2 (caller ID) (cr2):04 */
8638 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8639 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8640 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8641 /* Config. Reg. 4 (analog gain) (cr4):02 */
8642 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8643 /* Config. Reg. 5 (Version) (cr5):02 */
8644 /* Config. Reg. 6 (Reserved) (cr6):00 */
8645 /* Config. Reg. 7 (Reserved) (cr7):00 */
8646 /* ;xr Registers */
8647 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8648
8649 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8650 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8651
8652 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8653 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8654
8655 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8656 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8657 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8658 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8659 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8660 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8661 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8662 /* Ext. Reg. 6 (Power State) (xr6):00 */
8663 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8664 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8665 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8666
8667 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8668 /* 12,33,5A,C3 ; 770 Hz */
8669 /* 13,3C,5B,32 ; 852 Hz */
8670 /* 1D,1B,5C,CC ; 941 Hz */
8671 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8672 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8673 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8674 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8675
8676 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8677 /* EC,1D,52,22 ; 1336 Hz */
8678 /* AA,AC,51,D2 ; 1477 Hz */
8679 /* 9B,3B,51,25 ; 1633 Hz */
8680 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8681 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8682 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8683 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8684 }
8685
8686 static void DAA_Coeff_Japan(IXJ *j)
8687 {
8688 int i;
8689
8690 j->daa_country = DAA_JAPAN;
8691 /*----------------------------------------------- */
8692 /* CAO */
8693 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8694 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8695 }
8696
8697 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8706 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8708 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8709 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8710 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8711 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8712 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8713 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8714 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8715 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8724 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8726 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8727 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8728 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8729 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8730 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8731 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8732 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8733 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8734 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8735 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8736 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8737 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8738 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8739 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8740 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8741 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8742 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8743 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8752 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8761 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8763 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8764 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8765 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8766 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8767 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8768 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8769 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8770 /* ; idle */
8771 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8780 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8782 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8783 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8784 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8785 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8786 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8787 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8788 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8789 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8790 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8791 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8792 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8793 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8794 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8803 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8805 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8806 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8807 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8808 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8809 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8810 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8811 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8812 /* ;CR Registers */
8813 /* Config. Reg. 0 (filters) (cr0):FF */
8814 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8815 /* Config. Reg. 1 (dialing) (cr1):05 */
8816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8817 /* Config. Reg. 2 (caller ID) (cr2):04 */
8818 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8819 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8820 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8821 /* Config. Reg. 4 (analog gain) (cr4):02 */
8822 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8823 /* Config. Reg. 5 (Version) (cr5):02 */
8824 /* Config. Reg. 6 (Reserved) (cr6):00 */
8825 /* Config. Reg. 7 (Reserved) (cr7):00 */
8826 /* ;xr Registers */
8827 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8828
8829 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8830 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8831
8832 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8833 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8834
8835 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8836 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8837 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8838 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8839 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8840 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8841 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8842 /* Ext. Reg. 6 (Power State) (xr6):00 */
8843 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8844 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8845 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8846 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8847 /* 12,33,5A,C3 ; 770 Hz */
8848 /* 13,3C,5B,32 ; 852 Hz */
8849 /* 1D,1B,5C,CC ; 941 Hz */
8850
8851 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8852 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8853 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8855 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8856 /* EC,1D,52,22 ; 1336 Hz */
8857 /* AA,AC,51,D2 ; 1477 Hz */
8858 /* 9B,3B,51,25 ; 1633 Hz */
8859 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8860 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8861 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8862 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8863 }
8864
8865 static s16 tone_table[][19] =
8866 {
8867 { /* f20_50[] 11 */
8868 32538, /* A1 = 1.985962 */
8869 -32325, /* A2 = -0.986511 */
8870 -343, /* B2 = -0.010493 */
8871 0, /* B1 = 0 */
8872 343, /* B0 = 0.010493 */
8873 32619, /* A1 = 1.990906 */
8874 -32520, /* A2 = -0.992462 */
8875 19179, /* B2 = 0.585327 */
8876 -19178, /* B1 = -1.170593 */
8877 19179, /* B0 = 0.585327 */
8878 32723, /* A1 = 1.997314 */
8879 -32686, /* A2 = -0.997528 */
8880 9973, /* B2 = 0.304352 */
8881 -9955, /* B1 = -0.607605 */
8882 9973, /* B0 = 0.304352 */
8883 7, /* Internal filter scaling */
8884 159, /* Minimum in-band energy threshold */
8885 21, /* 21/32 in-band to broad-band ratio */
8886 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8887 },
8888 { /* f133_200[] 12 */
8889 32072, /* A1 = 1.95752 */
8890 -31896, /* A2 = -0.973419 */
8891 -435, /* B2 = -0.013294 */
8892 0, /* B1 = 0 */
8893 435, /* B0 = 0.013294 */
8894 32188, /* A1 = 1.9646 */
8895 -32400, /* A2 = -0.98877 */
8896 15139, /* B2 = 0.462036 */
8897 -14882, /* B1 = -0.908356 */
8898 15139, /* B0 = 0.462036 */
8899 32473, /* A1 = 1.981995 */
8900 -32524, /* A2 = -0.992584 */
8901 23200, /* B2 = 0.708008 */
8902 -23113, /* B1 = -1.410706 */
8903 23200, /* B0 = 0.708008 */
8904 7, /* Internal filter scaling */
8905 159, /* Minimum in-band energy threshold */
8906 21, /* 21/32 in-band to broad-band ratio */
8907 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8908 },
8909 { /* f300 13 */
8910 31769, /* A1 = -1.939026 */
8911 -32584, /* A2 = 0.994385 */
8912 -475, /* B2 = -0.014522 */
8913 0, /* B1 = 0.000000 */
8914 475, /* B0 = 0.014522 */
8915 31789, /* A1 = -1.940247 */
8916 -32679, /* A2 = 0.997284 */
8917 17280, /* B2 = 0.527344 */
8918 -16865, /* B1 = -1.029358 */
8919 17280, /* B0 = 0.527344 */
8920 31841, /* A1 = -1.943481 */
8921 -32681, /* A2 = 0.997345 */
8922 543, /* B2 = 0.016579 */
8923 -525, /* B1 = -0.032097 */
8924 543, /* B0 = 0.016579 */
8925 5, /* Internal filter scaling */
8926 159, /* Minimum in-band energy threshold */
8927 21, /* 21/32 in-band to broad-band ratio */
8928 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8929 },
8930 { /* f300_420[] 14 */
8931 30750, /* A1 = 1.876892 */
8932 -31212, /* A2 = -0.952515 */
8933 -804, /* B2 = -0.024541 */
8934 0, /* B1 = 0 */
8935 804, /* B0 = 0.024541 */
8936 30686, /* A1 = 1.872925 */
8937 -32145, /* A2 = -0.980988 */
8938 14747, /* B2 = 0.450043 */
8939 -13703, /* B1 = -0.836395 */
8940 14747, /* B0 = 0.450043 */
8941 31651, /* A1 = 1.931824 */
8942 -32321, /* A2 = -0.986389 */
8943 24425, /* B2 = 0.745422 */
8944 -23914, /* B1 = -1.459595 */
8945 24427, /* B0 = 0.745483 */
8946 7, /* Internal filter scaling */
8947 159, /* Minimum in-band energy threshold */
8948 21, /* 21/32 in-band to broad-band ratio */
8949 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8950 },
8951 { /* f330 15 */
8952 31613, /* A1 = -1.929565 */
8953 -32646, /* A2 = 0.996277 */
8954 -185, /* B2 = -0.005657 */
8955 0, /* B1 = 0.000000 */
8956 185, /* B0 = 0.005657 */
8957 31620, /* A1 = -1.929932 */
8958 -32713, /* A2 = 0.998352 */
8959 19253, /* B2 = 0.587585 */
8960 -18566, /* B1 = -1.133179 */
8961 19253, /* B0 = 0.587585 */
8962 31674, /* A1 = -1.933228 */
8963 -32715, /* A2 = 0.998413 */
8964 2575, /* B2 = 0.078590 */
8965 -2495, /* B1 = -0.152283 */
8966 2575, /* B0 = 0.078590 */
8967 5, /* Internal filter scaling */
8968 159, /* Minimum in-band energy threshold */
8969 21, /* 21/32 in-band to broad-band ratio */
8970 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8971 },
8972 { /* f300_425[] 16 */
8973 30741, /* A1 = 1.876282 */
8974 -31475, /* A2 = -0.960541 */
8975 -703, /* B2 = -0.021484 */
8976 0, /* B1 = 0 */
8977 703, /* B0 = 0.021484 */
8978 30688, /* A1 = 1.873047 */
8979 -32248, /* A2 = -0.984161 */
8980 14542, /* B2 = 0.443787 */
8981 -13523, /* B1 = -0.825439 */
8982 14542, /* B0 = 0.443817 */
8983 31494, /* A1 = 1.922302 */
8984 -32366, /* A2 = -0.987762 */
8985 21577, /* B2 = 0.658508 */
8986 -21013, /* B1 = -1.282532 */
8987 21577, /* B0 = 0.658508 */
8988 7, /* Internal filter scaling */
8989 159, /* Minimum in-band energy threshold */
8990 21, /* 21/32 in-band to broad-band ratio */
8991 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8992 },
8993 { /* f330_440[] 17 */
8994 30627, /* A1 = 1.869324 */
8995 -31338, /* A2 = -0.95636 */
8996 -843, /* B2 = -0.025749 */
8997 0, /* B1 = 0 */
8998 843, /* B0 = 0.025749 */
8999 30550, /* A1 = 1.864685 */
9000 -32221, /* A2 = -0.983337 */
9001 13594, /* B2 = 0.414886 */
9002 -12589, /* B1 = -0.768402 */
9003 13594, /* B0 = 0.414886 */
9004 31488, /* A1 = 1.921936 */
9005 -32358, /* A2 = -0.987518 */
9006 24684, /* B2 = 0.753296 */
9007 -24029, /* B1 = -1.466614 */
9008 24684, /* B0 = 0.753296 */
9009 7, /* Internal filter scaling */
9010 159, /* Minimum in-band energy threshold */
9011 21, /* 21/32 in-band to broad-band ratio */
9012 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9013 },
9014 { /* f340 18 */
9015 31546, /* A1 = -1.925476 */
9016 -32646, /* A2 = 0.996277 */
9017 -445, /* B2 = -0.013588 */
9018 0, /* B1 = 0.000000 */
9019 445, /* B0 = 0.013588 */
9020 31551, /* A1 = -1.925781 */
9021 -32713, /* A2 = 0.998352 */
9022 23884, /* B2 = 0.728882 */
9023 -22979, /* B1 = -1.402527 */
9024 23884, /* B0 = 0.728882 */
9025 31606, /* A1 = -1.929138 */
9026 -32715, /* A2 = 0.998413 */
9027 863, /* B2 = 0.026367 */
9028 -835, /* B1 = -0.050985 */
9029 863, /* B0 = 0.026367 */
9030 5, /* Internal filter scaling */
9031 159, /* Minimum in-band energy threshold */
9032 21, /* 21/32 in-band to broad-band ratio */
9033 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9034 },
9035 { /* f350_400[] 19 */
9036 31006, /* A1 = 1.892517 */
9037 -32029, /* A2 = -0.977448 */
9038 -461, /* B2 = -0.014096 */
9039 0, /* B1 = 0 */
9040 461, /* B0 = 0.014096 */
9041 30999, /* A1 = 1.892029 */
9042 -32487, /* A2 = -0.991455 */
9043 11325, /* B2 = 0.345612 */
9044 -10682, /* B1 = -0.651978 */
9045 11325, /* B0 = 0.345612 */
9046 31441, /* A1 = 1.919067 */
9047 -32526, /* A2 = -0.992615 */
9048 24324, /* B2 = 0.74231 */
9049 -23535, /* B1 = -1.436523 */
9050 24324, /* B0 = 0.74231 */
9051 7, /* Internal filter scaling */
9052 159, /* Minimum in-band energy threshold */
9053 21, /* 21/32 in-band to broad-band ratio */
9054 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9055 },
9056 { /* f350_440[] */
9057 30634, /* A1 = 1.869751 */
9058 -31533, /* A2 = -0.962341 */
9059 -680, /* B2 = -0.020782 */
9060 0, /* B1 = 0 */
9061 680, /* B0 = 0.020782 */
9062 30571, /* A1 = 1.865906 */
9063 -32277, /* A2 = -0.985016 */
9064 12894, /* B2 = 0.393524 */
9065 -11945, /* B1 = -0.729065 */
9066 12894, /* B0 = 0.393524 */
9067 31367, /* A1 = 1.91449 */
9068 -32379, /* A2 = -0.988129 */
9069 23820, /* B2 = 0.726929 */
9070 -23104, /* B1 = -1.410217 */
9071 23820, /* B0 = 0.726929 */
9072 7, /* Internal filter scaling */
9073 159, /* Minimum in-band energy threshold */
9074 21, /* 21/32 in-band to broad-band ratio */
9075 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9076 },
9077 { /* f350_450[] */
9078 30552, /* A1 = 1.864807 */
9079 -31434, /* A2 = -0.95929 */
9080 -690, /* B2 = -0.021066 */
9081 0, /* B1 = 0 */
9082 690, /* B0 = 0.021066 */
9083 30472, /* A1 = 1.859924 */
9084 -32248, /* A2 = -0.984161 */
9085 13385, /* B2 = 0.408478 */
9086 -12357, /* B1 = -0.754242 */
9087 13385, /* B0 = 0.408478 */
9088 31358, /* A1 = 1.914001 */
9089 -32366, /* A2 = -0.987732 */
9090 26488, /* B2 = 0.80835 */
9091 -25692, /* B1 = -1.568176 */
9092 26490, /* B0 = 0.808411 */
9093 7, /* Internal filter scaling */
9094 159, /* Minimum in-band energy threshold */
9095 21, /* 21/32 in-band to broad-band ratio */
9096 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9097 },
9098 { /* f360 */
9099 31397, /* A1 = -1.916321 */
9100 -32623, /* A2 = 0.995605 */
9101 -117, /* B2 = -0.003598 */
9102 0, /* B1 = 0.000000 */
9103 117, /* B0 = 0.003598 */
9104 31403, /* A1 = -1.916687 */
9105 -32700, /* A2 = 0.997925 */
9106 3388, /* B2 = 0.103401 */
9107 -3240, /* B1 = -0.197784 */
9108 3388, /* B0 = 0.103401 */
9109 31463, /* A1 = -1.920410 */
9110 -32702, /* A2 = 0.997986 */
9111 13346, /* B2 = 0.407288 */
9112 -12863, /* B1 = -0.785126 */
9113 13346, /* B0 = 0.407288 */
9114 5, /* Internal filter scaling */
9115 159, /* Minimum in-band energy threshold */
9116 21, /* 21/32 in-band to broad-band ratio */
9117 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9118 },
9119 { /* f380_420[] */
9120 30831, /* A1 = 1.881775 */
9121 -32064, /* A2 = -0.978546 */
9122 -367, /* B2 = -0.01122 */
9123 0, /* B1 = 0 */
9124 367, /* B0 = 0.01122 */
9125 30813, /* A1 = 1.880737 */
9126 -32456, /* A2 = -0.990509 */
9127 11068, /* B2 = 0.337769 */
9128 -10338, /* B1 = -0.631042 */
9129 11068, /* B0 = 0.337769 */
9130 31214, /* A1 = 1.905212 */
9131 -32491, /* A2 = -0.991577 */
9132 16374, /* B2 = 0.499695 */
9133 -15781, /* B1 = -0.963196 */
9134 16374, /* B0 = 0.499695 */
9135 7, /* Internal filter scaling */
9136 159, /* Minimum in-band energy threshold */
9137 21, /* 21/32 in-band to broad-band ratio */
9138 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9139 },
9140 { /* f392 */
9141 31152, /* A1 = -1.901428 */
9142 -32613, /* A2 = 0.995300 */
9143 -314, /* B2 = -0.009605 */
9144 0, /* B1 = 0.000000 */
9145 314, /* B0 = 0.009605 */
9146 31156, /* A1 = -1.901672 */
9147 -32694, /* A2 = 0.997742 */
9148 28847, /* B2 = 0.880371 */
9149 -2734, /* B1 = -0.166901 */
9150 28847, /* B0 = 0.880371 */
9151 31225, /* A1 = -1.905823 */
9152 -32696, /* A2 = 0.997803 */
9153 462, /* B2 = 0.014108 */
9154 -442, /* B1 = -0.027019 */
9155 462, /* B0 = 0.014108 */
9156 5, /* Internal filter scaling */
9157 159, /* Minimum in-band energy threshold */
9158 21, /* 21/32 in-band to broad-band ratio */
9159 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9160 },
9161 { /* f400_425[] */
9162 30836, /* A1 = 1.882141 */
9163 -32296, /* A2 = -0.985596 */
9164 -324, /* B2 = -0.009903 */
9165 0, /* B1 = 0 */
9166 324, /* B0 = 0.009903 */
9167 30825, /* A1 = 1.881409 */
9168 -32570, /* A2 = -0.993958 */
9169 16847, /* B2 = 0.51416 */
9170 -15792, /* B1 = -0.963898 */
9171 16847, /* B0 = 0.51416 */
9172 31106, /* A1 = 1.89856 */
9173 -32584, /* A2 = -0.994415 */
9174 9579, /* B2 = 0.292328 */
9175 -9164, /* B1 = -0.559357 */
9176 9579, /* B0 = 0.292328 */
9177 7, /* Internal filter scaling */
9178 159, /* Minimum in-band energy threshold */
9179 21, /* 21/32 in-band to broad-band ratio */
9180 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9181 },
9182 { /* f400_440[] */
9183 30702, /* A1 = 1.873962 */
9184 -32134, /* A2 = -0.980682 */
9185 -517, /* B2 = -0.015793 */
9186 0, /* B1 = 0 */
9187 517, /* B0 = 0.015793 */
9188 30676, /* A1 = 1.872375 */
9189 -32520, /* A2 = -0.992462 */
9190 8144, /* B2 = 0.24855 */
9191 -7596, /* B1 = -0.463684 */
9192 8144, /* B0 = 0.24855 */
9193 31084, /* A1 = 1.897217 */
9194 -32547, /* A2 = -0.993256 */
9195 22713, /* B2 = 0.693176 */
9196 -21734, /* B1 = -1.326599 */
9197 22713, /* B0 = 0.693176 */
9198 7, /* Internal filter scaling */
9199 159, /* Minimum in-band energy threshold */
9200 21, /* 21/32 in-band to broad-band ratio */
9201 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9202 },
9203 { /* f400_450[] */
9204 30613, /* A1 = 1.86853 */
9205 -32031, /* A2 = -0.977509 */
9206 -618, /* B2 = -0.018866 */
9207 0, /* B1 = 0 */
9208 618, /* B0 = 0.018866 */
9209 30577, /* A1 = 1.866272 */
9210 -32491, /* A2 = -0.991577 */
9211 9612, /* B2 = 0.293335 */
9212 -8935, /* B1 = -0.54541 */
9213 9612, /* B0 = 0.293335 */
9214 31071, /* A1 = 1.896484 */
9215 -32524, /* A2 = -0.992584 */
9216 21596, /* B2 = 0.659058 */
9217 -20667, /* B1 = -1.261414 */
9218 21596, /* B0 = 0.659058 */
9219 7, /* Internal filter scaling */
9220 159, /* Minimum in-band energy threshold */
9221 21, /* 21/32 in-band to broad-band ratio */
9222 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9223 },
9224 { /* f420 */
9225 30914, /* A1 = -1.886841 */
9226 -32584, /* A2 = 0.994385 */
9227 -426, /* B2 = -0.013020 */
9228 0, /* B1 = 0.000000 */
9229 426, /* B0 = 0.013020 */
9230 30914, /* A1 = -1.886841 */
9231 -32679, /* A2 = 0.997314 */
9232 17520, /* B2 = 0.534668 */
9233 -16471, /* B1 = -1.005310 */
9234 17520, /* B0 = 0.534668 */
9235 31004, /* A1 = -1.892334 */
9236 -32683, /* A2 = 0.997406 */
9237 819, /* B2 = 0.025023 */
9238 -780, /* B1 = -0.047619 */
9239 819, /* B0 = 0.025023 */
9240 5, /* Internal filter scaling */
9241 159, /* Minimum in-band energy threshold */
9242 21, /* 21/32 in-band to broad-band ratio */
9243 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9244 },
9245 #if 0
9246 { /* f425 */
9247 30881, /* A1 = -1.884827 */
9248 -32603, /* A2 = 0.994965 */
9249 -496, /* B2 = -0.015144 */
9250 0, /* B1 = 0.000000 */
9251 496, /* B0 = 0.015144 */
9252 30880, /* A1 = -1.884766 */
9253 -32692, /* A2 = 0.997711 */
9254 24767, /* B2 = 0.755859 */
9255 -23290, /* B1 = -1.421509 */
9256 24767, /* B0 = 0.755859 */
9257 30967, /* A1 = -1.890076 */
9258 -32694, /* A2 = 0.997772 */
9259 728, /* B2 = 0.022232 */
9260 -691, /* B1 = -0.042194 */
9261 728, /* B0 = 0.022232 */
9262 5, /* Internal filter scaling */
9263 159, /* Minimum in-band energy threshold */
9264 21, /* 21/32 in-band to broad-band ratio */
9265 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9266 },
9267 #else
9268 {
9269 30850,
9270 -32534,
9271 -504,
9272 0,
9273 504,
9274 30831,
9275 -32669,
9276 24303,
9277 -22080,
9278 24303,
9279 30994,
9280 -32673,
9281 1905,
9282 -1811,
9283 1905,
9284 5,
9285 129,
9286 17,
9287 0xff5
9288 },
9289 #endif
9290 { /* f425_450[] */
9291 30646, /* A1 = 1.870544 */
9292 -32327, /* A2 = -0.986572 */
9293 -287, /* B2 = -0.008769 */
9294 0, /* B1 = 0 */
9295 287, /* B0 = 0.008769 */
9296 30627, /* A1 = 1.869324 */
9297 -32607, /* A2 = -0.995087 */
9298 13269, /* B2 = 0.404968 */
9299 -12376, /* B1 = -0.755432 */
9300 13269, /* B0 = 0.404968 */
9301 30924, /* A1 = 1.887512 */
9302 -32619, /* A2 = -0.995453 */
9303 19950, /* B2 = 0.608826 */
9304 -18940, /* B1 = -1.156006 */
9305 19950, /* B0 = 0.608826 */
9306 7, /* Internal filter scaling */
9307 159, /* Minimum in-band energy threshold */
9308 21, /* 21/32 in-band to broad-band ratio */
9309 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9310 },
9311 { /* f425_475[] */
9312 30396, /* A1 = 1.855225 */
9313 -32014, /* A2 = -0.97699 */
9314 -395, /* B2 = -0.012055 */
9315 0, /* B1 = 0 */
9316 395, /* B0 = 0.012055 */
9317 30343, /* A1 = 1.85199 */
9318 -32482, /* A2 = -0.991302 */
9319 17823, /* B2 = 0.543945 */
9320 -16431, /* B1 = -1.002869 */
9321 17823, /* B0 = 0.543945 */
9322 30872, /* A1 = 1.884338 */
9323 -32516, /* A2 = -0.99231 */
9324 18124, /* B2 = 0.553101 */
9325 -17246, /* B1 = -1.052673 */
9326 18124, /* B0 = 0.553101 */
9327 7, /* Internal filter scaling */
9328 159, /* Minimum in-band energy threshold */
9329 21, /* 21/32 in-band to broad-band ratio */
9330 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9331 },
9332 { /* f435 */
9333 30796, /* A1 = -1.879639 */
9334 -32603, /* A2 = 0.994965 */
9335 -254, /* B2 = -0.007762 */
9336 0, /* B1 = 0.000000 */
9337 254, /* B0 = 0.007762 */
9338 30793, /* A1 = -1.879456 */
9339 -32692, /* A2 = 0.997711 */
9340 18934, /* B2 = 0.577820 */
9341 -17751, /* B1 = -1.083496 */
9342 18934, /* B0 = 0.577820 */
9343 30882, /* A1 = -1.884888 */
9344 -32694, /* A2 = 0.997772 */
9345 1858, /* B2 = 0.056713 */
9346 -1758, /* B1 = -0.107357 */
9347 1858, /* B0 = 0.056713 */
9348 5, /* Internal filter scaling */
9349 159, /* Minimum in-band energy threshold */
9350 21, /* 21/32 in-band to broad-band ratio */
9351 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9352 },
9353 { /* f440_450[] */
9354 30641, /* A1 = 1.870239 */
9355 -32458, /* A2 = -0.99057 */
9356 -155, /* B2 = -0.004735 */
9357 0, /* B1 = 0 */
9358 155, /* B0 = 0.004735 */
9359 30631, /* A1 = 1.869568 */
9360 -32630, /* A2 = -0.995789 */
9361 11453, /* B2 = 0.349548 */
9362 -10666, /* B1 = -0.651001 */
9363 11453, /* B0 = 0.349548 */
9364 30810, /* A1 = 1.880554 */
9365 -32634, /* A2 = -0.995941 */
9366 12237, /* B2 = 0.373474 */
9367 -11588, /* B1 = -0.707336 */
9368 12237, /* B0 = 0.373474 */
9369 7, /* Internal filter scaling */
9370 159, /* Minimum in-band energy threshold */
9371 21, /* 21/32 in-band to broad-band ratio */
9372 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9373 },
9374 { /* f440_480[] */
9375 30367, /* A1 = 1.853455 */
9376 -32147, /* A2 = -0.981079 */
9377 -495, /* B2 = -0.015113 */
9378 0, /* B1 = 0 */
9379 495, /* B0 = 0.015113 */
9380 30322, /* A1 = 1.850769 */
9381 -32543, /* A2 = -0.993134 */
9382 10031, /* B2 = 0.306152 */
9383 -9252, /* B1 = -0.564728 */
9384 10031, /* B0 = 0.306152 */
9385 30770, /* A1 = 1.878052 */
9386 -32563, /* A2 = -0.993774 */
9387 22674, /* B2 = 0.691956 */
9388 -21465, /* B1 = -1.31012 */
9389 22674, /* B0 = 0.691956 */
9390 7, /* Internal filter scaling */
9391 159, /* Minimum in-band energy threshold */
9392 21, /* 21/32 in-band to broad-band ratio */
9393 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394 },
9395 { /* f445 */
9396 30709, /* A1 = -1.874329 */
9397 -32603, /* A2 = 0.994965 */
9398 -83, /* B2 = -0.002545 */
9399 0, /* B1 = 0.000000 */
9400 83, /* B0 = 0.002545 */
9401 30704, /* A1 = -1.874084 */
9402 -32692, /* A2 = 0.997711 */
9403 10641, /* B2 = 0.324738 */
9404 -9947, /* B1 = -0.607147 */
9405 10641, /* B0 = 0.324738 */
9406 30796, /* A1 = -1.879639 */
9407 -32694, /* A2 = 0.997772 */
9408 10079, /* B2 = 0.307587 */
9409 9513, /* B1 = 0.580688 */
9410 10079, /* B0 = 0.307587 */
9411 5, /* Internal filter scaling */
9412 159, /* Minimum in-band energy threshold */
9413 21, /* 21/32 in-band to broad-band ratio */
9414 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9415 },
9416 { /* f450 */
9417 30664, /* A1 = -1.871643 */
9418 -32603, /* A2 = 0.994965 */
9419 -164, /* B2 = -0.005029 */
9420 0, /* B1 = 0.000000 */
9421 164, /* B0 = 0.005029 */
9422 30661, /* A1 = -1.871399 */
9423 -32692, /* A2 = 0.997711 */
9424 15294, /* B2 = 0.466736 */
9425 -14275, /* B1 = -0.871307 */
9426 15294, /* B0 = 0.466736 */
9427 30751, /* A1 = -1.876953 */
9428 -32694, /* A2 = 0.997772 */
9429 3548, /* B2 = 0.108284 */
9430 -3344, /* B1 = -0.204155 */
9431 3548, /* B0 = 0.108284 */
9432 5, /* Internal filter scaling */
9433 159, /* Minimum in-band energy threshold */
9434 21, /* 21/32 in-band to broad-band ratio */
9435 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9436 },
9437 { /* f452 */
9438 30653, /* A1 = -1.870911 */
9439 -32615, /* A2 = 0.995361 */
9440 -209, /* B2 = -0.006382 */
9441 0, /* B1 = 0.000000 */
9442 209, /* B0 = 0.006382 */
9443 30647, /* A1 = -1.870605 */
9444 -32702, /* A2 = 0.997986 */
9445 18971, /* B2 = 0.578979 */
9446 -17716, /* B1 = -1.081299 */
9447 18971, /* B0 = 0.578979 */
9448 30738, /* A1 = -1.876099 */
9449 -32702, /* A2 = 0.998016 */
9450 2967, /* B2 = 0.090561 */
9451 -2793, /* B1 = -0.170502 */
9452 2967, /* B0 = 0.090561 */
9453 5, /* Internal filter scaling */
9454 159, /* Minimum in-band energy threshold */
9455 21, /* 21/32 in-band to broad-band ratio */
9456 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9457 },
9458 { /* f475 */
9459 30437, /* A1 = -1.857727 */
9460 -32603, /* A2 = 0.994965 */
9461 -264, /* B2 = -0.008062 */
9462 0, /* B1 = 0.000000 */
9463 264, /* B0 = 0.008062 */
9464 30430, /* A1 = -1.857300 */
9465 -32692, /* A2 = 0.997711 */
9466 21681, /* B2 = 0.661682 */
9467 -20082, /* B1 = -1.225708 */
9468 21681, /* B0 = 0.661682 */
9469 30526, /* A1 = -1.863220 */
9470 -32694, /* A2 = 0.997742 */
9471 1559, /* B2 = 0.047600 */
9472 -1459, /* B1 = -0.089096 */
9473 1559, /* B0 = 0.047600 */
9474 5, /* Internal filter scaling */
9475 159, /* Minimum in-band energy threshold */
9476 21, /* 21/32 in-band to broad-band ratio */
9477 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9478 },
9479 { /* f480_620[] */
9480 28975, /* A1 = 1.768494 */
9481 -30955, /* A2 = -0.944672 */
9482 -1026, /* B2 = -0.03133 */
9483 0, /* B1 = 0 */
9484 1026, /* B0 = 0.03133 */
9485 28613, /* A1 = 1.746399 */
9486 -32089, /* A2 = -0.979309 */
9487 14214, /* B2 = 0.433807 */
9488 -12202, /* B1 = -0.744812 */
9489 14214, /* B0 = 0.433807 */
9490 30243, /* A1 = 1.845947 */
9491 -32238, /* A2 = -0.983856 */
9492 24825, /* B2 = 0.757629 */
9493 -23402, /* B1 = -1.428345 */
9494 24825, /* B0 = 0.757629 */
9495 7, /* Internal filter scaling */
9496 159, /* Minimum in-band energy threshold */
9497 21, /* 21/32 in-band to broad-band ratio */
9498 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9499 },
9500 { /* f494 */
9501 30257, /* A1 = -1.846741 */
9502 -32605, /* A2 = 0.995056 */
9503 -249, /* B2 = -0.007625 */
9504 0, /* B1 = 0.000000 */
9505 249, /* B0 = 0.007625 */
9506 30247, /* A1 = -1.846191 */
9507 -32694, /* A2 = 0.997772 */
9508 18088, /* B2 = 0.552002 */
9509 -16652, /* B1 = -1.016418 */
9510 18088, /* B0 = 0.552002 */
9511 30348, /* A1 = -1.852295 */
9512 -32696, /* A2 = 0.997803 */
9513 2099, /* B2 = 0.064064 */
9514 -1953, /* B1 = -0.119202 */
9515 2099, /* B0 = 0.064064 */
9516 5, /* Internal filter scaling */
9517 159, /* Minimum in-band energy threshold */
9518 21, /* 21/32 in-band to broad-band ratio */
9519 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9520 },
9521 { /* f500 */
9522 30202, /* A1 = -1.843431 */
9523 -32624, /* A2 = 0.995622 */
9524 -413, /* B2 = -0.012622 */
9525 0, /* B1 = 0.000000 */
9526 413, /* B0 = 0.012622 */
9527 30191, /* A1 = -1.842721 */
9528 -32714, /* A2 = 0.998364 */
9529 25954, /* B2 = 0.792057 */
9530 -23890, /* B1 = -1.458131 */
9531 25954, /* B0 = 0.792057 */
9532 30296, /* A1 = -1.849172 */
9533 -32715, /* A2 = 0.998397 */
9534 2007, /* B2 = 0.061264 */
9535 -1860, /* B1 = -0.113568 */
9536 2007, /* B0 = 0.061264 */
9537 5, /* Internal filter scaling */
9538 159, /* Minimum in-band energy threshold */
9539 21, /* 21/32 in-band to broad-band ratio */
9540 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9541 },
9542 { /* f520 */
9543 30001, /* A1 = -1.831116 */
9544 -32613, /* A2 = 0.995270 */
9545 -155, /* B2 = -0.004750 */
9546 0, /* B1 = 0.000000 */
9547 155, /* B0 = 0.004750 */
9548 29985, /* A1 = -1.830200 */
9549 -32710, /* A2 = 0.998260 */
9550 6584, /* B2 = 0.200928 */
9551 -6018, /* B1 = -0.367355 */
9552 6584, /* B0 = 0.200928 */
9553 30105, /* A1 = -1.837524 */
9554 -32712, /* A2 = 0.998291 */
9555 23812, /* B2 = 0.726685 */
9556 -21936, /* B1 = -1.338928 */
9557 23812, /* B0 = 0.726685 */
9558 5, /* Internal filter scaling */
9559 159, /* Minimum in-band energy threshold */
9560 21, /* 21/32 in-band to broad-band ratio */
9561 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9562 },
9563 { /* f523 */
9564 29964, /* A1 = -1.828918 */
9565 -32601, /* A2 = 0.994904 */
9566 -101, /* B2 = -0.003110 */
9567 0, /* B1 = 0.000000 */
9568 101, /* B0 = 0.003110 */
9569 29949, /* A1 = -1.827942 */
9570 -32700, /* A2 = 0.997925 */
9571 11041, /* B2 = 0.336975 */
9572 -10075, /* B1 = -0.614960 */
9573 11041, /* B0 = 0.336975 */
9574 30070, /* A1 = -1.835388 */
9575 -32702, /* A2 = 0.997986 */
9576 16762, /* B2 = 0.511536 */
9577 -15437, /* B1 = -0.942230 */
9578 16762, /* B0 = 0.511536 */
9579 5, /* Internal filter scaling */
9580 159, /* Minimum in-band energy threshold */
9581 21, /* 21/32 in-band to broad-band ratio */
9582 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9583 },
9584 { /* f525 */
9585 29936, /* A1 = -1.827209 */
9586 -32584, /* A2 = 0.994415 */
9587 -91, /* B2 = -0.002806 */
9588 0, /* B1 = 0.000000 */
9589 91, /* B0 = 0.002806 */
9590 29921, /* A1 = -1.826233 */
9591 -32688, /* A2 = 0.997559 */
9592 11449, /* B2 = 0.349396 */
9593 -10426, /* B1 = -0.636383 */
9594 11449, /* B0 = 0.349396 */
9595 30045, /* A1 = -1.833862 */
9596 -32688, /* A2 = 0.997589 */
9597 13055, /* B2 = 0.398407 */
9598 -12028, /* B1 = -0.734161 */
9599 13055, /* B0 = 0.398407 */
9600 5, /* Internal filter scaling */
9601 159, /* Minimum in-band energy threshold */
9602 21, /* 21/32 in-band to broad-band ratio */
9603 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9604 },
9605 { /* f540_660[] */
9606 28499, /* A1 = 1.739441 */
9607 -31129, /* A2 = -0.949982 */
9608 -849, /* B2 = -0.025922 */
9609 0, /* B1 = 0 */
9610 849, /* B0 = 0.025922 */
9611 28128, /* A1 = 1.716797 */
9612 -32130, /* A2 = -0.98056 */
9613 14556, /* B2 = 0.444214 */
9614 -12251, /* B1 = -0.747772 */
9615 14556, /* B0 = 0.444244 */
9616 29667, /* A1 = 1.81073 */
9617 -32244, /* A2 = -0.984039 */
9618 23038, /* B2 = 0.703064 */
9619 -21358, /* B1 = -1.303589 */
9620 23040, /* B0 = 0.703125 */
9621 7, /* Internal filter scaling */
9622 159, /* Minimum in-band energy threshold */
9623 21, /* 21/32 in-band to broad-band ratio */
9624 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9625 },
9626 { /* f587 */
9627 29271, /* A1 = -1.786560 */
9628 -32599, /* A2 = 0.994873 */
9629 -490, /* B2 = -0.014957 */
9630 0, /* B1 = 0.000000 */
9631 490, /* B0 = 0.014957 */
9632 29246, /* A1 = -1.785095 */
9633 -32700, /* A2 = 0.997925 */
9634 28961, /* B2 = 0.883850 */
9635 -25796, /* B1 = -1.574463 */
9636 28961, /* B0 = 0.883850 */
9637 29383, /* A1 = -1.793396 */
9638 -32700, /* A2 = 0.997955 */
9639 1299, /* B2 = 0.039650 */
9640 -1169, /* B1 = -0.071396 */
9641 1299, /* B0 = 0.039650 */
9642 5, /* Internal filter scaling */
9643 159, /* Minimum in-band energy threshold */
9644 21, /* 21/32 in-band to broad-band ratio */
9645 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9646 },
9647 { /* f590 */
9648 29230, /* A1 = -1.784058 */
9649 -32584, /* A2 = 0.994415 */
9650 -418, /* B2 = -0.012757 */
9651 0, /* B1 = 0.000000 */
9652 418, /* B0 = 0.012757 */
9653 29206, /* A1 = -1.782593 */
9654 -32688, /* A2 = 0.997559 */
9655 36556, /* B2 = 1.115601 */
9656 -32478, /* B1 = -1.982300 */
9657 36556, /* B0 = 1.115601 */
9658 29345, /* A1 = -1.791077 */
9659 -32688, /* A2 = 0.997589 */
9660 897, /* B2 = 0.027397 */
9661 -808, /* B1 = -0.049334 */
9662 897, /* B0 = 0.027397 */
9663 5, /* Internal filter scaling */
9664 159, /* Minimum in-band energy threshold */
9665 21, /* 21/32 in-band to broad-band ratio */
9666 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9667 },
9668 { /* f600 */
9669 29116, /* A1 = -1.777100 */
9670 -32603, /* A2 = 0.994965 */
9671 -165, /* B2 = -0.005039 */
9672 0, /* B1 = 0.000000 */
9673 165, /* B0 = 0.005039 */
9674 29089, /* A1 = -1.775452 */
9675 -32708, /* A2 = 0.998199 */
9676 6963, /* B2 = 0.212494 */
9677 -6172, /* B1 = -0.376770 */
9678 6963, /* B0 = 0.212494 */
9679 29237, /* A1 = -1.784485 */
9680 -32710, /* A2 = 0.998230 */
9681 24197, /* B2 = 0.738464 */
9682 -21657, /* B1 = -1.321899 */
9683 24197, /* B0 = 0.738464 */
9684 5, /* Internal filter scaling */
9685 159, /* Minimum in-band energy threshold */
9686 21, /* 21/32 in-band to broad-band ratio */
9687 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9688 },
9689 { /* f660 */
9690 28376, /* A1 = -1.731934 */
9691 -32567, /* A2 = 0.993896 */
9692 -363, /* B2 = -0.011102 */
9693 0, /* B1 = 0.000000 */
9694 363, /* B0 = 0.011102 */
9695 28337, /* A1 = -1.729614 */
9696 -32683, /* A2 = 0.997434 */
9697 21766, /* B2 = 0.664246 */
9698 -18761, /* B1 = -1.145081 */
9699 21766, /* B0 = 0.664246 */
9700 28513, /* A1 = -1.740356 */
9701 -32686, /* A2 = 0.997498 */
9702 2509, /* B2 = 0.076584 */
9703 -2196, /* B1 = -0.134041 */
9704 2509, /* B0 = 0.076584 */
9705 5, /* Internal filter scaling */
9706 159, /* Minimum in-band energy threshold */
9707 21, /* 21/32 in-band to broad-band ratio */
9708 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9709 },
9710 { /* f700 */
9711 27844, /* A1 = -1.699463 */
9712 -32563, /* A2 = 0.993744 */
9713 -366, /* B2 = -0.011187 */
9714 0, /* B1 = 0.000000 */
9715 366, /* B0 = 0.011187 */
9716 27797, /* A1 = -1.696655 */
9717 -32686, /* A2 = 0.997498 */
9718 22748, /* B2 = 0.694214 */
9719 -19235, /* B1 = -1.174072 */
9720 22748, /* B0 = 0.694214 */
9721 27995, /* A1 = -1.708740 */
9722 -32688, /* A2 = 0.997559 */
9723 2964, /* B2 = 0.090477 */
9724 -2546, /* B1 = -0.155449 */
9725 2964, /* B0 = 0.090477 */
9726 5, /* Internal filter scaling */
9727 159, /* Minimum in-band energy threshold */
9728 21, /* 21/32 in-band to broad-band ratio */
9729 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9730 },
9731 { /* f740 */
9732 27297, /* A1 = -1.666077 */
9733 -32551, /* A2 = 0.993408 */
9734 -345, /* B2 = -0.010540 */
9735 0, /* B1 = 0.000000 */
9736 345, /* B0 = 0.010540 */
9737 27240, /* A1 = -1.662598 */
9738 -32683, /* A2 = 0.997406 */
9739 22560, /* B2 = 0.688477 */
9740 -18688, /* B1 = -1.140625 */
9741 22560, /* B0 = 0.688477 */
9742 27461, /* A1 = -1.676147 */
9743 -32684, /* A2 = 0.997467 */
9744 3541, /* B2 = 0.108086 */
9745 -2985, /* B1 = -0.182220 */
9746 3541, /* B0 = 0.108086 */
9747 5, /* Internal filter scaling */
9748 159, /* Minimum in-band energy threshold */
9749 21, /* 21/32 in-band to broad-band ratio */
9750 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9751 },
9752 { /* f750 */
9753 27155, /* A1 = -1.657410 */
9754 -32551, /* A2 = 0.993408 */
9755 -462, /* B2 = -0.014117 */
9756 0, /* B1 = 0.000000 */
9757 462, /* B0 = 0.014117 */
9758 27097, /* A1 = -1.653870 */
9759 -32683, /* A2 = 0.997406 */
9760 32495, /* B2 = 0.991699 */
9761 -26776, /* B1 = -1.634338 */
9762 32495, /* B0 = 0.991699 */
9763 27321, /* A1 = -1.667542 */
9764 -32684, /* A2 = 0.997467 */
9765 1835, /* B2 = 0.056007 */
9766 -1539, /* B1 = -0.093948 */
9767 1835, /* B0 = 0.056007 */
9768 5, /* Internal filter scaling */
9769 159, /* Minimum in-band energy threshold */
9770 21, /* 21/32 in-band to broad-band ratio */
9771 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9772 },
9773 { /* f750_1450[] */
9774 19298, /* A1 = 1.177917 */
9775 -24471, /* A2 = -0.746796 */
9776 -4152, /* B2 = -0.126709 */
9777 0, /* B1 = 0 */
9778 4152, /* B0 = 0.126709 */
9779 12902, /* A1 = 0.787476 */
9780 -29091, /* A2 = -0.887817 */
9781 12491, /* B2 = 0.38121 */
9782 -1794, /* B1 = -0.109528 */
9783 12494, /* B0 = 0.381317 */
9784 26291, /* A1 = 1.604736 */
9785 -30470, /* A2 = -0.929901 */
9786 28859, /* B2 = 0.880737 */
9787 -26084, /* B1 = -1.592102 */
9788 28861, /* B0 = 0.880798 */
9789 7, /* Internal filter scaling */
9790 159, /* Minimum in-band energy threshold */
9791 21, /* 21/32 in-band to broad-band ratio */
9792 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9793 },
9794 { /* f770 */
9795 26867, /* A1 = -1.639832 */
9796 -32551, /* A2 = 0.993408 */
9797 -123, /* B2 = -0.003755 */
9798 0, /* B1 = 0.000000 */
9799 123, /* B0 = 0.003755 */
9800 26805, /* A1 = -1.636108 */
9801 -32683, /* A2 = 0.997406 */
9802 17297, /* B2 = 0.527863 */
9803 -14096, /* B1 = -0.860382 */
9804 17297, /* B0 = 0.527863 */
9805 27034, /* A1 = -1.650085 */
9806 -32684, /* A2 = 0.997467 */
9807 12958, /* B2 = 0.395477 */
9808 -10756, /* B1 = -0.656525 */
9809 12958, /* B0 = 0.395477 */
9810 5, /* Internal filter scaling */
9811 159, /* Minimum in-band energy threshold */
9812 21, /* 21/32 in-band to broad-band ratio */
9813 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9814 },
9815 { /* f800 */
9816 26413, /* A1 = -1.612122 */
9817 -32547, /* A2 = 0.993286 */
9818 -223, /* B2 = -0.006825 */
9819 0, /* B1 = 0.000000 */
9820 223, /* B0 = 0.006825 */
9821 26342, /* A1 = -1.607849 */
9822 -32686, /* A2 = 0.997498 */
9823 6391, /* B2 = 0.195053 */
9824 -5120, /* B1 = -0.312531 */
9825 6391, /* B0 = 0.195053 */
9826 26593, /* A1 = -1.623108 */
9827 -32688, /* A2 = 0.997559 */
9828 23681, /* B2 = 0.722717 */
9829 -19328, /* B1 = -1.179688 */
9830 23681, /* B0 = 0.722717 */
9831 5, /* Internal filter scaling */
9832 159, /* Minimum in-band energy threshold */
9833 21, /* 21/32 in-band to broad-band ratio */
9834 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9835 },
9836 { /* f816 */
9837 26168, /* A1 = -1.597209 */
9838 -32528, /* A2 = 0.992706 */
9839 -235, /* B2 = -0.007182 */
9840 0, /* B1 = 0.000000 */
9841 235, /* B0 = 0.007182 */
9842 26092, /* A1 = -1.592590 */
9843 -32675, /* A2 = 0.997192 */
9844 20823, /* B2 = 0.635498 */
9845 -16510, /* B1 = -1.007751 */
9846 20823, /* B0 = 0.635498 */
9847 26363, /* A1 = -1.609070 */
9848 -32677, /* A2 = 0.997253 */
9849 6739, /* B2 = 0.205688 */
9850 -5459, /* B1 = -0.333206 */
9851 6739, /* B0 = 0.205688 */
9852 5, /* Internal filter scaling */
9853 159, /* Minimum in-band energy threshold */
9854 21, /* 21/32 in-band to broad-band ratio */
9855 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9856 },
9857 { /* f850 */
9858 25641, /* A1 = -1.565063 */
9859 -32536, /* A2 = 0.992950 */
9860 -121, /* B2 = -0.003707 */
9861 0, /* B1 = 0.000000 */
9862 121, /* B0 = 0.003707 */
9863 25560, /* A1 = -1.560059 */
9864 -32684, /* A2 = 0.997437 */
9865 18341, /* B2 = 0.559753 */
9866 -14252, /* B1 = -0.869904 */
9867 18341, /* B0 = 0.559753 */
9868 25837, /* A1 = -1.577026 */
9869 -32684, /* A2 = 0.997467 */
9870 16679, /* B2 = 0.509003 */
9871 -13232, /* B1 = -0.807648 */
9872 16679, /* B0 = 0.509003 */
9873 5, /* Internal filter scaling */
9874 159, /* Minimum in-band energy threshold */
9875 21, /* 21/32 in-band to broad-band ratio */
9876 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9877 },
9878 { /* f857_1645[] */
9879 16415, /* A1 = 1.001953 */
9880 -23669, /* A2 = -0.722321 */
9881 -4549, /* B2 = -0.138847 */
9882 0, /* B1 = 0 */
9883 4549, /* B0 = 0.138847 */
9884 8456, /* A1 = 0.516174 */
9885 -28996, /* A2 = -0.884918 */
9886 13753, /* B2 = 0.419724 */
9887 -12, /* B1 = -0.000763 */
9888 13757, /* B0 = 0.419846 */
9889 24632, /* A1 = 1.503418 */
9890 -30271, /* A2 = -0.923828 */
9891 29070, /* B2 = 0.887146 */
9892 -25265, /* B1 = -1.542114 */
9893 29073, /* B0 = 0.887268 */
9894 7, /* Internal filter scaling */
9895 159, /* Minimum in-band energy threshold */
9896 21, /* 21/32 in-band to broad-band ratio */
9897 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9898 },
9899 { /* f900 */
9900 24806, /* A1 = -1.514099 */
9901 -32501, /* A2 = 0.991852 */
9902 -326, /* B2 = -0.009969 */
9903 0, /* B1 = 0.000000 */
9904 326, /* B0 = 0.009969 */
9905 24709, /* A1 = -1.508118 */
9906 -32659, /* A2 = 0.996674 */
9907 20277, /* B2 = 0.618835 */
9908 -15182, /* B1 = -0.926636 */
9909 20277, /* B0 = 0.618835 */
9910 25022, /* A1 = -1.527222 */
9911 -32661, /* A2 = 0.996735 */
9912 4320, /* B2 = 0.131836 */
9913 -3331, /* B1 = -0.203339 */
9914 4320, /* B0 = 0.131836 */
9915 5, /* Internal filter scaling */
9916 159, /* Minimum in-band energy threshold */
9917 21, /* 21/32 in-band to broad-band ratio */
9918 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9919 },
9920 { /* f900_1300[] */
9921 19776, /* A1 = 1.207092 */
9922 -27437, /* A2 = -0.837341 */
9923 -2666, /* B2 = -0.081371 */
9924 0, /* B1 = 0 */
9925 2666, /* B0 = 0.081371 */
9926 16302, /* A1 = 0.995026 */
9927 -30354, /* A2 = -0.926361 */
9928 10389, /* B2 = 0.317062 */
9929 -3327, /* B1 = -0.203064 */
9930 10389, /* B0 = 0.317062 */
9931 24299, /* A1 = 1.483154 */
9932 -30930, /* A2 = -0.943909 */
9933 25016, /* B2 = 0.763428 */
9934 -21171, /* B1 = -1.292236 */
9935 25016, /* B0 = 0.763428 */
9936 7, /* Internal filter scaling */
9937 159, /* Minimum in-band energy threshold */
9938 21, /* 21/32 in-band to broad-band ratio */
9939 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9940 },
9941 { /* f935_1215[] */
9942 20554, /* A1 = 1.254517 */
9943 -28764, /* A2 = -0.877838 */
9944 -2048, /* B2 = -0.062515 */
9945 0, /* B1 = 0 */
9946 2048, /* B0 = 0.062515 */
9947 18209, /* A1 = 1.11145 */
9948 -30951, /* A2 = -0.94458 */
9949 9390, /* B2 = 0.286575 */
9950 -3955, /* B1 = -0.241455 */
9951 9390, /* B0 = 0.286575 */
9952 23902, /* A1 = 1.458923 */
9953 -31286, /* A2 = -0.954803 */
9954 23252, /* B2 = 0.709595 */
9955 -19132, /* B1 = -1.167725 */
9956 23252, /* B0 = 0.709595 */
9957 7, /* Internal filter scaling */
9958 159, /* Minimum in-band energy threshold */
9959 21, /* 21/32 in-band to broad-band ratio */
9960 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9961 },
9962 { /* f941_1477[] */
9963 17543, /* A1 = 1.07074 */
9964 -26220, /* A2 = -0.800201 */
9965 -3298, /* B2 = -0.100647 */
9966 0, /* B1 = 0 */
9967 3298, /* B0 = 0.100647 */
9968 12423, /* A1 = 0.75827 */
9969 -30036, /* A2 = -0.916626 */
9970 12651, /* B2 = 0.386078 */
9971 -2444, /* B1 = -0.14917 */
9972 12653, /* B0 = 0.386154 */
9973 23518, /* A1 = 1.435425 */
9974 -30745, /* A2 = -0.938293 */
9975 27282, /* B2 = 0.832581 */
9976 -22529, /* B1 = -1.375122 */
9977 27286, /* B0 = 0.832703 */
9978 7, /* Internal filter scaling */
9979 159, /* Minimum in-band energy threshold */
9980 21, /* 21/32 in-band to broad-band ratio */
9981 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9982 },
9983 { /* f942 */
9984 24104, /* A1 = -1.471252 */
9985 -32507, /* A2 = 0.992065 */
9986 -351, /* B2 = -0.010722 */
9987 0, /* B1 = 0.000000 */
9988 351, /* B0 = 0.010722 */
9989 23996, /* A1 = -1.464600 */
9990 -32671, /* A2 = 0.997040 */
9991 22848, /* B2 = 0.697266 */
9992 -16639, /* B1 = -1.015564 */
9993 22848, /* B0 = 0.697266 */
9994 24332, /* A1 = -1.485168 */
9995 -32673, /* A2 = 0.997101 */
9996 4906, /* B2 = 0.149727 */
9997 -3672, /* B1 = -0.224174 */
9998 4906, /* B0 = 0.149727 */
9999 5, /* Internal filter scaling */
10000 159, /* Minimum in-band energy threshold */
10001 21, /* 21/32 in-band to broad-band ratio */
10002 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10003 },
10004 { /* f950 */
10005 23967, /* A1 = -1.462830 */
10006 -32507, /* A2 = 0.992065 */
10007 -518, /* B2 = -0.015821 */
10008 0, /* B1 = 0.000000 */
10009 518, /* B0 = 0.015821 */
10010 23856, /* A1 = -1.456055 */
10011 -32671, /* A2 = 0.997040 */
10012 26287, /* B2 = 0.802246 */
10013 -19031, /* B1 = -1.161560 */
10014 26287, /* B0 = 0.802246 */
10015 24195, /* A1 = -1.476746 */
10016 -32673, /* A2 = 0.997101 */
10017 2890, /* B2 = 0.088196 */
10018 -2151, /* B1 = -0.131317 */
10019 2890, /* B0 = 0.088196 */
10020 5, /* Internal filter scaling */
10021 159, /* Minimum in-band energy threshold */
10022 21, /* 21/32 in-band to broad-band ratio */
10023 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10024 },
10025 { /* f950_1400[] */
10026 18294, /* A1 = 1.116638 */
10027 -26962, /* A2 = -0.822845 */
10028 -2914, /* B2 = -0.088936 */
10029 0, /* B1 = 0 */
10030 2914, /* B0 = 0.088936 */
10031 14119, /* A1 = 0.861786 */
10032 -30227, /* A2 = -0.922455 */
10033 11466, /* B2 = 0.349945 */
10034 -2833, /* B1 = -0.172943 */
10035 11466, /* B0 = 0.349945 */
10036 23431, /* A1 = 1.430115 */
10037 -30828, /* A2 = -0.940796 */
10038 25331, /* B2 = 0.773071 */
10039 -20911, /* B1 = -1.276367 */
10040 25331, /* B0 = 0.773071 */
10041 7, /* Internal filter scaling */
10042 159, /* Minimum in-band energy threshold */
10043 21, /* 21/32 in-band to broad-band ratio */
10044 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10045 },
10046 { /* f975 */
10047 23521, /* A1 = -1.435608 */
10048 -32489, /* A2 = 0.991516 */
10049 -193, /* B2 = -0.005915 */
10050 0, /* B1 = 0.000000 */
10051 193, /* B0 = 0.005915 */
10052 23404, /* A1 = -1.428467 */
10053 -32655, /* A2 = 0.996582 */
10054 17740, /* B2 = 0.541412 */
10055 -12567, /* B1 = -0.767029 */
10056 17740, /* B0 = 0.541412 */
10057 23753, /* A1 = -1.449829 */
10058 -32657, /* A2 = 0.996613 */
10059 9090, /* B2 = 0.277405 */
10060 -6662, /* B1 = -0.406647 */
10061 9090, /* B0 = 0.277405 */
10062 5, /* Internal filter scaling */
10063 159, /* Minimum in-band energy threshold */
10064 21, /* 21/32 in-band to broad-band ratio */
10065 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10066 },
10067 { /* f1000 */
10068 23071, /* A1 = -1.408203 */
10069 -32489, /* A2 = 0.991516 */
10070 -293, /* B2 = -0.008965 */
10071 0, /* B1 = 0.000000 */
10072 293, /* B0 = 0.008965 */
10073 22951, /* A1 = -1.400818 */
10074 -32655, /* A2 = 0.996582 */
10075 5689, /* B2 = 0.173645 */
10076 -3951, /* B1 = -0.241150 */
10077 5689, /* B0 = 0.173645 */
10078 23307, /* A1 = -1.422607 */
10079 -32657, /* A2 = 0.996613 */
10080 18692, /* B2 = 0.570435 */
10081 -13447, /* B1 = -0.820770 */
10082 18692, /* B0 = 0.570435 */
10083 5, /* Internal filter scaling */
10084 159, /* Minimum in-band energy threshold */
10085 21, /* 21/32 in-band to broad-band ratio */
10086 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10087 },
10088 { /* f1020 */
10089 22701, /* A1 = -1.385620 */
10090 -32474, /* A2 = 0.991058 */
10091 -292, /* B2 = -0.008933 */
10092 0, /*163840 , B1 = 10.000000 */
10093 292, /* B0 = 0.008933 */
10094 22564, /* A1 = -1.377258 */
10095 -32655, /* A2 = 0.996552 */
10096 20756, /* B2 = 0.633423 */
10097 -14176, /* B1 = -0.865295 */
10098 20756, /* B0 = 0.633423 */
10099 22960, /* A1 = -1.401428 */
10100 -32657, /* A2 = 0.996613 */
10101 6520, /* B2 = 0.198990 */
10102 -4619, /* B1 = -0.281937 */
10103 6520, /* B0 = 0.198990 */
10104 5, /* Internal filter scaling */
10105 159, /* Minimum in-band energy threshold */
10106 21, /* 21/32 in-band to broad-band ratio */
10107 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10108 },
10109 { /* f1050 */
10110 22142, /* A1 = -1.351501 */
10111 -32474, /* A2 = 0.991058 */
10112 -147, /* B2 = -0.004493 */
10113 0, /* B1 = 0.000000 */
10114 147, /* B0 = 0.004493 */
10115 22000, /* A1 = -1.342834 */
10116 -32655, /* A2 = 0.996552 */
10117 15379, /* B2 = 0.469360 */
10118 -10237, /* B1 = -0.624847 */
10119 15379, /* B0 = 0.469360 */
10120 22406, /* A1 = -1.367554 */
10121 -32657, /* A2 = 0.996613 */
10122 17491, /* B2 = 0.533783 */
10123 -12096, /* B1 = -0.738312 */
10124 17491, /* B0 = 0.533783 */
10125 5, /* Internal filter scaling */
10126 159, /* Minimum in-band energy threshold */
10127 21, /* 21/32 in-band to broad-band ratio */
10128 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10129 },
10130 { /* f1100_1750[] */
10131 12973, /* A1 = 0.79184 */
10132 -24916, /* A2 = -0.760376 */
10133 6655, /* B2 = 0.203102 */
10134 367, /* B1 = 0.0224 */
10135 6657, /* B0 = 0.203171 */
10136 5915, /* A1 = 0.361053 */
10137 -29560, /* A2 = -0.90213 */
10138 -7777, /* B2 = -0.23735 */
10139 0, /* B1 = 0 */
10140 7777, /* B0 = 0.23735 */
10141 20510, /* A1 = 1.251892 */
10142 -30260, /* A2 = -0.923462 */
10143 26662, /* B2 = 0.81366 */
10144 -20573, /* B1 = -1.255737 */
10145 26668, /* B0 = 0.813843 */
10146 7, /* Internal filter scaling */
10147 159, /* Minimum in-band energy threshold */
10148 21, /* 21/32 in-band to broad-band ratio */
10149 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10150 },
10151 { /* f1140 */
10152 20392, /* A1 = -1.244629 */
10153 -32460, /* A2 = 0.990601 */
10154 -270, /* B2 = -0.008240 */
10155 0, /* B1 = 0.000000 */
10156 270, /* B0 = 0.008240 */
10157 20218, /* A1 = -1.234009 */
10158 -32655, /* A2 = 0.996582 */
10159 21337, /* B2 = 0.651154 */
10160 -13044, /* B1 = -0.796143 */
10161 21337, /* B0 = 0.651154 */
10162 20684, /* A1 = -1.262512 */
10163 -32657, /* A2 = 0.996643 */
10164 8572, /* B2 = 0.261612 */
10165 -5476, /* B1 = -0.334244 */
10166 8572, /* B0 = 0.261612 */
10167 5, /* Internal filter scaling */
10168 159, /* Minimum in-band energy threshold */
10169 21, /* 21/32 in-band to broad-band ratio */
10170 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10171 },
10172 { /* f1200 */
10173 19159, /* A1 = -1.169373 */
10174 -32456, /* A2 = 0.990509 */
10175 -335, /* B2 = -0.010252 */
10176 0, /* B1 = 0.000000 */
10177 335, /* B0 = 0.010252 */
10178 18966, /* A1 = -1.157593 */
10179 -32661, /* A2 = 0.996735 */
10180 6802, /* B2 = 0.207588 */
10181 -3900, /* B1 = -0.238098 */
10182 6802, /* B0 = 0.207588 */
10183 19467, /* A1 = -1.188232 */
10184 -32661, /* A2 = 0.996765 */
10185 25035, /* B2 = 0.764008 */
10186 -15049, /* B1 = -0.918579 */
10187 25035, /* B0 = 0.764008 */
10188 5, /* Internal filter scaling */
10189 159, /* Minimum in-band energy threshold */
10190 21, /* 21/32 in-band to broad-band ratio */
10191 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10192 },
10193 { /* f1209 */
10194 18976, /* A1 = -1.158264 */
10195 -32439, /* A2 = 0.989990 */
10196 -183, /* B2 = -0.005588 */
10197 0, /* B1 = 0.000000 */
10198 183, /* B0 = 0.005588 */
10199 18774, /* A1 = -1.145874 */
10200 -32650, /* A2 = 0.996429 */
10201 15468, /* B2 = 0.472076 */
10202 -8768, /* B1 = -0.535217 */
10203 15468, /* B0 = 0.472076 */
10204 19300, /* A1 = -1.177979 */
10205 -32652, /* A2 = 0.996490 */
10206 19840, /* B2 = 0.605499 */
10207 -11842, /* B1 = -0.722809 */
10208 19840, /* B0 = 0.605499 */
10209 5, /* Internal filter scaling */
10210 159, /* Minimum in-band energy threshold */
10211 21, /* 21/32 in-band to broad-band ratio */
10212 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10213 },
10214 { /* f1330 */
10215 16357, /* A1 = -0.998413 */
10216 -32368, /* A2 = 0.987793 */
10217 -217, /* B2 = -0.006652 */
10218 0, /* B1 = 0.000000 */
10219 217, /* B0 = 0.006652 */
10220 16107, /* A1 = -0.983126 */
10221 -32601, /* A2 = 0.994904 */
10222 11602, /* B2 = 0.354065 */
10223 -5555, /* B1 = -0.339111 */
10224 11602, /* B0 = 0.354065 */
10225 16722, /* A1 = -1.020630 */
10226 -32603, /* A2 = 0.994965 */
10227 15574, /* B2 = 0.475311 */
10228 -8176, /* B1 = -0.499069 */
10229 15574, /* B0 = 0.475311 */
10230 5, /* Internal filter scaling */
10231 159, /* Minimum in-band energy threshold */
10232 21, /* 21/32 in-band to broad-band ratio */
10233 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10234 },
10235 { /* f1336 */
10236 16234, /* A1 = -0.990875 */
10237 32404, /* A2 = -0.988922 */
10238 -193, /* B2 = -0.005908 */
10239 0, /* B1 = 0.000000 */
10240 193, /* B0 = 0.005908 */
10241 15986, /* A1 = -0.975769 */
10242 -32632, /* A2 = 0.995880 */
10243 18051, /* B2 = 0.550903 */
10244 -8658, /* B1 = -0.528473 */
10245 18051, /* B0 = 0.550903 */
10246 16591, /* A1 = -1.012695 */
10247 -32634, /* A2 = 0.995941 */
10248 15736, /* B2 = 0.480240 */
10249 -8125, /* B1 = -0.495926 */
10250 15736, /* B0 = 0.480240 */
10251 5, /* Internal filter scaling */
10252 159, /* Minimum in-band energy threshold */
10253 21, /* 21/32 in-band to broad-band ratio */
10254 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10255 },
10256 { /* f1366 */
10257 15564, /* A1 = -0.949982 */
10258 -32404, /* A2 = 0.988922 */
10259 -269, /* B2 = -0.008216 */
10260 0, /* B1 = 0.000000 */
10261 269, /* B0 = 0.008216 */
10262 15310, /* A1 = -0.934479 */
10263 -32632, /* A2 = 0.995880 */
10264 10815, /* B2 = 0.330063 */
10265 -4962, /* B1 = -0.302887 */
10266 10815, /* B0 = 0.330063 */
10267 15924, /* A1 = -0.971924 */
10268 -32634, /* A2 = 0.995941 */
10269 18880, /* B2 = 0.576172 */
10270 -9364, /* B1 = -0.571594 */
10271 18880, /* B0 = 0.576172 */
10272 5, /* Internal filter scaling */
10273 159, /* Minimum in-band energy threshold */
10274 21, /* 21/32 in-band to broad-band ratio */
10275 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10276 },
10277 { /* f1380 */
10278 15247, /* A1 = -0.930603 */
10279 -32397, /* A2 = 0.988708 */
10280 -244, /* B2 = -0.007451 */
10281 0, /* B1 = 0.000000 */
10282 244, /* B0 = 0.007451 */
10283 14989, /* A1 = -0.914886 */
10284 -32627, /* A2 = 0.995697 */
10285 18961, /* B2 = 0.578644 */
10286 -8498, /* B1 = -0.518707 */
10287 18961, /* B0 = 0.578644 */
10288 15608, /* A1 = -0.952667 */
10289 -32628, /* A2 = 0.995758 */
10290 11145, /* B2 = 0.340134 */
10291 -5430, /* B1 = -0.331467 */
10292 11145, /* B0 = 0.340134 */
10293 5, /* Internal filter scaling */
10294 159, /* Minimum in-band energy threshold */
10295 21, /* 21/32 in-band to broad-band ratio */
10296 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10297 },
10298 { /* f1400 */
10299 14780, /* A1 = -0.902130 */
10300 -32393, /* A2 = 0.988586 */
10301 -396, /* B2 = -0.012086 */
10302 0, /* B1 = 0.000000 */
10303 396, /* B0 = 0.012086 */
10304 14510, /* A1 = -0.885651 */
10305 -32630, /* A2 = 0.995819 */
10306 6326, /* B2 = 0.193069 */
10307 -2747, /* B1 = -0.167671 */
10308 6326, /* B0 = 0.193069 */
10309 15154, /* A1 = -0.924957 */
10310 -32632, /* A2 = 0.995850 */
10311 23235, /* B2 = 0.709076 */
10312 -10983, /* B1 = -0.670380 */
10313 23235, /* B0 = 0.709076 */
10314 5, /* Internal filter scaling */
10315 159, /* Minimum in-band energy threshold */
10316 21, /* 21/32 in-band to broad-band ratio */
10317 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10318 },
10319 { /* f1477 */
10320 13005, /* A1 = -0.793793 */
10321 -32368, /* A2 = 0.987823 */
10322 -500, /* B2 = -0.015265 */
10323 0, /* B1 = 0.000000 */
10324 500, /* B0 = 0.015265 */
10325 12708, /* A1 = -0.775665 */
10326 -32615, /* A2 = 0.995331 */
10327 11420, /* B2 = 0.348526 */
10328 -4306, /* B1 = -0.262833 */
10329 11420, /* B0 = 0.348526 */
10330 13397, /* A1 = -0.817688 */
10331 -32615, /* A2 = 0.995361 */
10332 9454, /* B2 = 0.288528 */
10333 -3981, /* B1 = -0.243027 */
10334 9454, /* B0 = 0.288528 */
10335 5, /* Internal filter scaling */
10336 159, /* Minimum in-band energy threshold */
10337 21, /* 21/32 in-band to broad-band ratio */
10338 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10339 },
10340 { /* f1600 */
10341 10046, /* A1 = -0.613190 */
10342 -32331, /* A2 = 0.986694 */
10343 -455, /* B2 = -0.013915 */
10344 0, /* B1 = 0.000000 */
10345 455, /* B0 = 0.013915 */
10346 9694, /* A1 = -0.591705 */
10347 -32601, /* A2 = 0.994934 */
10348 6023, /* B2 = 0.183815 */
10349 -1708, /* B1 = -0.104279 */
10350 6023, /* B0 = 0.183815 */
10351 10478, /* A1 = -0.639587 */
10352 -32603, /* A2 = 0.994965 */
10353 22031, /* B2 = 0.672333 */
10354 -7342, /* B1 = -0.448151 */
10355 22031, /* B0 = 0.672333 */
10356 5, /* Internal filter scaling */
10357 159, /* Minimum in-band energy threshold */
10358 21, /* 21/32 in-band to broad-band ratio */
10359 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10360 },
10361 { /* f1633_1638[] */
10362 9181, /* A1 = 0.560394 */
10363 -32256, /* A2 = -0.984375 */
10364 -556, /* B2 = -0.016975 */
10365 0, /* B1 = 0 */
10366 556, /* B0 = 0.016975 */
10367 8757, /* A1 = 0.534515 */
10368 -32574, /* A2 = -0.99408 */
10369 8443, /* B2 = 0.25769 */
10370 -2135, /* B1 = -0.130341 */
10371 8443, /* B0 = 0.25769 */
10372 9691, /* A1 = 0.591522 */
10373 -32574, /* A2 = -0.99411 */
10374 15446, /* B2 = 0.471375 */
10375 -4809, /* B1 = -0.293579 */
10376 15446, /* B0 = 0.471375 */
10377 7, /* Internal filter scaling */
10378 159, /* Minimum in-band energy threshold */
10379 21, /* 21/32 in-band to broad-band ratio */
10380 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10381 },
10382 { /* f1800 */
10383 5076, /* A1 = -0.309875 */
10384 -32304, /* A2 = 0.985840 */
10385 -508, /* B2 = -0.015503 */
10386 0, /* B1 = 0.000000 */
10387 508, /* B0 = 0.015503 */
10388 4646, /* A1 = -0.283600 */
10389 -32605, /* A2 = 0.995026 */
10390 6742, /* B2 = 0.205780 */
10391 -878, /* B1 = -0.053635 */
10392 6742, /* B0 = 0.205780 */
10393 5552, /* A1 = -0.338928 */
10394 -32605, /* A2 = 0.995056 */
10395 23667, /* B2 = 0.722260 */
10396 -4297, /* B1 = -0.262329 */
10397 23667, /* B0 = 0.722260 */
10398 5, /* Internal filter scaling */
10399 159, /* Minimum in-band energy threshold */
10400 21, /* 21/32 in-band to broad-band ratio */
10401 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10402 },
10403 { /* f1860 */
10404 3569, /* A1 = -0.217865 */
10405 -32292, /* A2 = 0.985504 */
10406 -239, /* B2 = -0.007322 */
10407 0, /* B1 = 0.000000 */
10408 239, /* B0 = 0.007322 */
10409 3117, /* A1 = -0.190277 */
10410 -32603, /* A2 = 0.994965 */
10411 18658, /* B2 = 0.569427 */
10412 -1557, /* B1 = -0.095032 */
10413 18658, /* B0 = 0.569427 */
10414 4054, /* A1 = -0.247437 */
10415 -32603, /* A2 = 0.994965 */
10416 18886, /* B2 = 0.576385 */
10417 -2566, /* B1 = -0.156647 */
10418 18886, /* B0 = 0.576385 */
10419 5, /* Internal filter scaling */
10420 159, /* Minimum in-band energy threshold */
10421 21, /* 21/32 in-band to broad-band ratio */
10422 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10423 },
10424 };
10425 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10426 {
10427 unsigned short cmd;
10428 int cnt, max;
10429
10430 if (jf->filter > 3) {
10431 return -1;
10432 }
10433 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10434
10435 return -1;
10436 if (!jf->enable) {
10437 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10438
10439 return -1;
10440 else
10441 return 0;
10442 } else {
10443 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10444
10445 return -1;
10446 /* Select the filter (f0 - f3) to use. */
10447 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10448 return -1;
10449 }
10450 if (jf->freq < 12 && jf->freq > 3) {
10451 /* Select the frequency for the selected filter. */
10452 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10453 return -1;
10454 } else if (jf->freq > 11) {
10455 /* We need to load a programmable filter set for undefined */
10456 /* frequencies. So we will point the filter to a programmable set. */
10457 /* Since there are only 4 filters and 4 programmable sets, we will */
10458 /* just point the filter to the same number set and program it for the */
10459 /* frequency we want. */
10460 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10461 return -1;
10462 if (j->ver.low != 0x12) {
10463 cmd = 0x515B;
10464 max = 19;
10465 } else {
10466 cmd = 0x515E;
10467 max = 15;
10468 }
10469 if (ixj_WriteDSPCommand(cmd, j))
10470 return -1;
10471 for (cnt = 0; cnt < max; cnt++) {
10472 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10473 return -1;
10474 }
10475 }
10476 j->filter_en[jf->filter] = jf->enable;
10477 return 0;
10478 }
10479
10480 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10481 {
10482 unsigned short cmd;
10483 int cnt, max;
10484 if (jfr->filter > 3) {
10485 return -1;
10486 }
10487 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10488 return -1;
10489
10490 if (!jfr->enable) {
10491 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10492 return -1;
10493 else
10494 return 0;
10495 } else {
10496 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10497 return -1;
10498 /* Select the filter (f0 - f3) to use. */
10499 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10500 return -1;
10501 }
10502 /* We need to load a programmable filter set for undefined */
10503 /* frequencies. So we will point the filter to a programmable set. */
10504 /* Since there are only 4 filters and 4 programmable sets, we will */
10505 /* just point the filter to the same number set and program it for the */
10506 /* frequency we want. */
10507 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10508 return -1;
10509 if (j->ver.low != 0x12) {
10510 cmd = 0x515B;
10511 max = 19;
10512 } else {
10513 cmd = 0x515E;
10514 max = 15;
10515 }
10516 if (ixj_WriteDSPCommand(cmd, j))
10517 return -1;
10518 for (cnt = 0; cnt < max; cnt++) {
10519 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10520 return -1;
10521 }
10522 j->filter_en[jfr->filter] = jfr->enable;
10523 return 0;
10524 }
10525
10526 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10527 {
10528 int freq0, freq1;
10529 unsigned short data;
10530 if (ti->freq0) {
10531 freq0 = ti->freq0;
10532 } else {
10533 freq0 = 0x7FFF;
10534 }
10535
10536 if (ti->freq1) {
10537 freq1 = ti->freq1;
10538 } else {
10539 freq1 = 0x7FFF;
10540 }
10541
10542 if(ti->tone_index > 12 && ti->tone_index < 28)
10543 {
10544 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10545 return -1;
10546 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10547 return -1;
10548 data = freq0;
10549 if (ixj_WriteDSPCommand(data, j))
10550 return -1;
10551 data = freq1;
10552 if (ixj_WriteDSPCommand(data, j))
10553 return -1;
10554 }
10555 return freq0;
10556 }
10557
Verdex Pro support