?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.2
[linux/fpc-iii.git] / drivers / telephony / ixj.c
blobd5f923bcdffeb907191297082b61cd5551226c39
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 succeeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246 #include "ixj-ver.h"
247
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251
252 #include <linux/module.h>
253
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/mutex.h>
261 #include <linux/mm.h>
262 #include <linux/ioport.h>
263 #include <linux/interrupt.h>
264 #include <linux/proc_fs.h>
265 #include <linux/poll.h>
266 #include <linux/timer.h>
267 #include <linux/delay.h>
268 #include <linux/pci.h>
269
270 #include <asm/io.h>
271 #include <asm/uaccess.h>
272
273 #include <linux/isapnp.h>
274
275 #include "ixj.h"
276
277 #define TYPE(inode) (iminor(inode) >> 4)
278 #define NUM(inode) (iminor(inode) & 0xf)
279
280 static DEFINE_MUTEX(ixj_mutex);
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 module_param(ixjdebug, int, 0);
286
287 static DEFINE_PCI_DEVICE_TABLE(ixj_pci_tbl) = {
288 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
289 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
290 { }
291 };
292 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
293
294 /************************************************************************
295 *
296 * ixjdebug meanings are now bit mapped instead of level based
297 * Values can be or'ed together to turn on multiple messages
298 *
299 * bit 0 (0x0001) = any failure
300 * bit 1 (0x0002) = general messages
301 * bit 2 (0x0004) = POTS ringing related
302 * bit 3 (0x0008) = PSTN events
303 * bit 4 (0x0010) = PSTN Cadence state details
304 * bit 5 (0x0020) = Tone detection triggers
305 * bit 6 (0x0040) = Tone detection cadence details
306 * bit 7 (0x0080) = ioctl tracking
307 * bit 8 (0x0100) = signal tracking
308 * bit 9 (0x0200) = CallerID generation details
309 *
310 ************************************************************************/
311
312 #ifdef IXJ_DYN_ALLOC
313
314 static IXJ *ixj[IXJMAX];
315 #define get_ixj(b) ixj[(b)]
316
317 /*
318 * Allocate a free IXJ device
319 */
320
321 static IXJ *ixj_alloc()
322 {
323 for(cnt=0; cnt<IXJMAX; cnt++)
324 {
325 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
326 {
327 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
328 if (j == NULL)
329 return NULL;
330 ixj[cnt] = j;
331 return j;
332 }
333 }
334 return NULL;
335 }
336
337 static void ixj_fsk_free(IXJ *j)
338 {
339 kfree(j->fskdata);
340 j->fskdata = NULL;
341 }
342
343 static void ixj_fsk_alloc(IXJ *j)
344 {
345 if(!j->fskdata) {
346 j->fskdata = kmalloc(8000, GFP_KERNEL);
347 if (!j->fskdata) {
348 if(ixjdebug & 0x0200) {
349 printk("IXJ phone%d - allocate failed\n", j->board);
350 }
351 return;
352 } else {
353 j->fsksize = 8000;
354 if(ixjdebug & 0x0200) {
355 printk("IXJ phone%d - allocate succeeded\n", j->board);
356 }
357 }
358 }
359 }
360
361 #else
362
363 static IXJ ixj[IXJMAX];
364 #define get_ixj(b) (&ixj[(b)])
365
366 /*
367 * Allocate a free IXJ device
368 */
369
370 static IXJ *ixj_alloc(void)
371 {
372 int cnt;
373 for(cnt=0; cnt<IXJMAX; cnt++) {
374 if(!ixj[cnt].DSPbase)
375 return &ixj[cnt];
376 }
377 return NULL;
378 }
379
380 static inline void ixj_fsk_free(IXJ *j) {;}
381
382 static inline void ixj_fsk_alloc(IXJ *j)
383 {
384 j->fsksize = 8000;
385 }
386
387 #endif
388
389 #ifdef PERFMON_STATS
390 #define ixj_perfmon(x) ((x)++)
391 #else
392 #define ixj_perfmon(x) do { } while(0)
393 #endif
394
395 static int ixj_convert_loaded;
396
397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
398
399 /************************************************************************
400 *
401 * These are function definitions to allow external modules to register
402 * enhanced functionality call backs.
403 *
404 ************************************************************************/
405
406 static int Stub(IXJ * J, unsigned long arg)
407 {
408 return 0;
409 }
410
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415
416 static void ixj_read_frame(IXJ *j);
417 static void ixj_write_frame(IXJ *j);
418 static void ixj_init_timer(IXJ *j);
419 static void ixj_add_timer(IXJ * j);
420 static void ixj_timeout(unsigned long ptr);
421 static int read_filters(IXJ *j);
422 static int LineMonitor(IXJ *j);
423 static int ixj_fasync(int fd, struct file *, int mode);
424 static int ixj_set_port(IXJ *j, int arg);
425 static int ixj_set_pots(IXJ *j, int arg);
426 static int ixj_hookstate(IXJ *j);
427 static int ixj_record_start(IXJ *j);
428 static void ixj_record_stop(IXJ *j);
429 static void set_rec_volume(IXJ *j, int volume);
430 static int get_rec_volume(IXJ *j);
431 static int set_rec_codec(IXJ *j, int rate);
432 static void ixj_vad(IXJ *j, int arg);
433 static int ixj_play_start(IXJ *j);
434 static void ixj_play_stop(IXJ *j);
435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
436 static int ixj_set_tone_off(unsigned short, IXJ *j);
437 static int ixj_play_tone(IXJ *j, char tone);
438 static void ixj_aec_start(IXJ *j, int level);
439 static int idle(IXJ *j);
440 static void ixj_ring_on(IXJ *j);
441 static void ixj_ring_off(IXJ *j);
442 static void aec_stop(IXJ *j);
443 static void ixj_ringback(IXJ *j);
444 static void ixj_busytone(IXJ *j);
445 static void ixj_dialtone(IXJ *j);
446 static void ixj_cpt_stop(IXJ *j);
447 static char daa_int_read(IXJ *j);
448 static char daa_CR_read(IXJ *j, int cr);
449 static int daa_set_mode(IXJ *j, int mode);
450 static int ixj_linetest(IXJ *j);
451 static int ixj_daa_write(IXJ *j);
452 static int ixj_daa_cid_read(IXJ *j);
453 static void DAA_Coeff_US(IXJ *j);
454 static void DAA_Coeff_UK(IXJ *j);
455 static void DAA_Coeff_France(IXJ *j);
456 static void DAA_Coeff_Germany(IXJ *j);
457 static void DAA_Coeff_Australia(IXJ *j);
458 static void DAA_Coeff_Japan(IXJ *j);
459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
464 /* Serial Control Interface funtions */
465 static int SCI_Control(IXJ *j, int control);
466 static int SCI_Prepare(IXJ *j);
467 static int SCI_WaitHighSCI(IXJ *j);
468 static int SCI_WaitLowSCI(IXJ *j);
469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
470 static int ixj_PCcontrol_wait(IXJ *j);
471 static void ixj_pre_cid(IXJ *j);
472 static void ixj_write_cid(IXJ *j);
473 static void ixj_write_cid_bit(IXJ *j, int bit);
474 static int set_base_frame(IXJ *j, int size);
475 static int set_play_codec(IXJ *j, int rate);
476 static void set_rec_depth(IXJ *j, int depth);
477 static int ixj_mixer(long val, IXJ *j);
478
479 /************************************************************************
480 CT8020/CT8021 Host Programmers Model
481 Host address Function Access
482 DSPbase +
483 0-1 Aux Software Status Register (reserved) Read Only
484 2-3 Software Status Register Read Only
485 4-5 Aux Software Control Register (reserved) Read Write
486 6-7 Software Control Register Read Write
487 8-9 Hardware Status Register Read Only
488 A-B Hardware Control Register Read Write
489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
490 E-F Host Receive (Read) Data Buffer Access Port (buffer input) Read Only
491 ************************************************************************/
492
493 static inline void ixj_read_HSR(IXJ *j)
494 {
495 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
496 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
497 }
498
499 static inline int IsControlReady(IXJ *j)
500 {
501 ixj_read_HSR(j);
502 return j->hsr.bits.controlrdy ? 1 : 0;
503 }
504
505 static inline int IsPCControlReady(IXJ *j)
506 {
507 j->pccr1.byte = inb_p(j->XILINXbase + 3);
508 return j->pccr1.bits.crr ? 1 : 0;
509 }
510
511 static inline int IsStatusReady(IXJ *j)
512 {
513 ixj_read_HSR(j);
514 return j->hsr.bits.statusrdy ? 1 : 0;
515 }
516
517 static inline int IsRxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->rxreadycheck);
521 return j->hsr.bits.rxrdy ? 1 : 0;
522 }
523
524 static inline int IsTxReady(IXJ *j)
525 {
526 ixj_read_HSR(j);
527 ixj_perfmon(j->txreadycheck);
528 return j->hsr.bits.txrdy ? 1 : 0;
529 }
530
531 static inline void set_play_volume(IXJ *j, int volume)
532 {
533 if (ixjdebug & 0x0002)
534 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
535 ixj_WriteDSPCommand(0xCF02, j);
536 ixj_WriteDSPCommand(volume, j);
537 }
538
539 static int set_play_volume_linear(IXJ *j, int volume)
540 {
541 int newvolume, dspplaymax;
542
543 if (ixjdebug & 0x0002)
544 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
545 if(volume > 100 || volume < 0) {
546 return -1;
547 }
548
549 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
550 switch (j->cardtype) {
551 case QTI_PHONEJACK:
552 dspplaymax = 0x380;
553 break;
554 case QTI_LINEJACK:
555 if(j->port == PORT_PSTN) {
556 dspplaymax = 0x48;
557 } else {
558 dspplaymax = 0x100;
559 }
560 break;
561 case QTI_PHONEJACK_LITE:
562 dspplaymax = 0x380;
563 break;
564 case QTI_PHONEJACK_PCI:
565 dspplaymax = 0x6C;
566 break;
567 case QTI_PHONECARD:
568 dspplaymax = 0x50;
569 break;
570 default:
571 return -1;
572 }
573 newvolume = (dspplaymax * volume) / 100;
574 set_play_volume(j, newvolume);
575 return 0;
576 }
577
578 static inline void set_play_depth(IXJ *j, int depth)
579 {
580 if (depth > 60)
581 depth = 60;
582 if (depth < 0)
583 depth = 0;
584 ixj_WriteDSPCommand(0x5280 + depth, j);
585 }
586
587 static inline int get_play_volume(IXJ *j)
588 {
589 ixj_WriteDSPCommand(0xCF00, j);
590 return j->ssr.high << 8 | j->ssr.low;
591 }
592
593 static int get_play_volume_linear(IXJ *j)
594 {
595 int volume, newvolume, dspplaymax;
596
597 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
598 switch (j->cardtype) {
599 case QTI_PHONEJACK:
600 dspplaymax = 0x380;
601 break;
602 case QTI_LINEJACK:
603 if(j->port == PORT_PSTN) {
604 dspplaymax = 0x48;
605 } else {
606 dspplaymax = 0x100;
607 }
608 break;
609 case QTI_PHONEJACK_LITE:
610 dspplaymax = 0x380;
611 break;
612 case QTI_PHONEJACK_PCI:
613 dspplaymax = 0x6C;
614 break;
615 case QTI_PHONECARD:
616 dspplaymax = 100;
617 break;
618 default:
619 return -1;
620 }
621 volume = get_play_volume(j);
622 newvolume = (volume * 100) / dspplaymax;
623 if(newvolume > 100)
624 newvolume = 100;
625 return newvolume;
626 }
627
628 static inline BYTE SLIC_GetState(IXJ *j)
629 {
630 if (j->cardtype == QTI_PHONECARD) {
631 j->pccr1.byte = 0;
632 j->psccr.bits.dev = 3;
633 j->psccr.bits.rw = 1;
634 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
635 ixj_PCcontrol_wait(j);
636 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
637 ixj_PCcontrol_wait(j);
638 if (j->pslic.bits.powerdown)
639 return PLD_SLIC_STATE_OC;
640 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
641 return PLD_SLIC_STATE_ACTIVE;
642 else
643 return PLD_SLIC_STATE_RINGING;
644 } else {
645 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
646 }
647 return j->pld_slicr.bits.state;
648 }
649
650 static bool SLIC_SetState(BYTE byState, IXJ *j)
651 {
652 bool fRetVal = false;
653
654 if (j->cardtype == QTI_PHONECARD) {
655 if (j->flags.pcmciasct) {
656 switch (byState) {
657 case PLD_SLIC_STATE_TIPOPEN:
658 case PLD_SLIC_STATE_OC:
659 j->pslic.bits.powerdown = 1;
660 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
661 fRetVal = true;
662 break;
663 case PLD_SLIC_STATE_RINGING:
664 if (j->readers || j->writers) {
665 j->pslic.bits.powerdown = 0;
666 j->pslic.bits.ring0 = 1;
667 j->pslic.bits.ring1 = 0;
668 fRetVal = true;
669 }
670 break;
671 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
672
673 case PLD_SLIC_STATE_STANDBY:
674 case PLD_SLIC_STATE_ACTIVE:
675 if (j->readers || j->writers) {
676 j->pslic.bits.powerdown = 0;
677 } else {
678 j->pslic.bits.powerdown = 1;
679 }
680 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
681 fRetVal = true;
682 break;
683 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
684
685 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
686
687 default:
688 fRetVal = false;
689 break;
690 }
691 j->psccr.bits.dev = 3;
692 j->psccr.bits.rw = 0;
693 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
694 ixj_PCcontrol_wait(j);
695 }
696 } else {
697 /* Set the C1, C2, C3 & B2EN signals. */
698 switch (byState) {
699 case PLD_SLIC_STATE_OC:
700 j->pld_slicw.bits.c1 = 0;
701 j->pld_slicw.bits.c2 = 0;
702 j->pld_slicw.bits.c3 = 0;
703 j->pld_slicw.bits.b2en = 0;
704 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
705 fRetVal = true;
706 break;
707 case PLD_SLIC_STATE_RINGING:
708 j->pld_slicw.bits.c1 = 1;
709 j->pld_slicw.bits.c2 = 0;
710 j->pld_slicw.bits.c3 = 0;
711 j->pld_slicw.bits.b2en = 1;
712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
713 fRetVal = true;
714 break;
715 case PLD_SLIC_STATE_ACTIVE:
716 j->pld_slicw.bits.c1 = 0;
717 j->pld_slicw.bits.c2 = 1;
718 j->pld_slicw.bits.c3 = 0;
719 j->pld_slicw.bits.b2en = 0;
720 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
721 fRetVal = true;
722 break;
723 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
724
725 j->pld_slicw.bits.c1 = 1;
726 j->pld_slicw.bits.c2 = 1;
727 j->pld_slicw.bits.c3 = 0;
728 j->pld_slicw.bits.b2en = 0;
729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
730 fRetVal = true;
731 break;
732 case PLD_SLIC_STATE_TIPOPEN:
733 j->pld_slicw.bits.c1 = 0;
734 j->pld_slicw.bits.c2 = 0;
735 j->pld_slicw.bits.c3 = 1;
736 j->pld_slicw.bits.b2en = 0;
737 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
738 fRetVal = true;
739 break;
740 case PLD_SLIC_STATE_STANDBY:
741 j->pld_slicw.bits.c1 = 1;
742 j->pld_slicw.bits.c2 = 0;
743 j->pld_slicw.bits.c3 = 1;
744 j->pld_slicw.bits.b2en = 1;
745 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
746 fRetVal = true;
747 break;
748 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
749
750 j->pld_slicw.bits.c1 = 0;
751 j->pld_slicw.bits.c2 = 1;
752 j->pld_slicw.bits.c3 = 1;
753 j->pld_slicw.bits.b2en = 0;
754 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
755 fRetVal = true;
756 break;
757 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
758
759 j->pld_slicw.bits.c1 = 1;
760 j->pld_slicw.bits.c2 = 1;
761 j->pld_slicw.bits.c3 = 1;
762 j->pld_slicw.bits.b2en = 0;
763 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
764 fRetVal = true;
765 break;
766 default:
767 fRetVal = false;
768 break;
769 }
770 }
771
772 return fRetVal;
773 }
774
775 static int ixj_wink(IXJ *j)
776 {
777 BYTE slicnow;
778
779 slicnow = SLIC_GetState(j);
780
781 j->pots_winkstart = jiffies;
782 SLIC_SetState(PLD_SLIC_STATE_OC, j);
783
784 msleep(jiffies_to_msecs(j->winktime));
785
786 SLIC_SetState(slicnow, j);
787 return 0;
788 }
789
790 static void ixj_init_timer(IXJ *j)
791 {
792 init_timer(&j->timer);
793 j->timer.function = ixj_timeout;
794 j->timer.data = (unsigned long)j;
795 }
796
797 static void ixj_add_timer(IXJ *j)
798 {
799 j->timer.expires = jiffies + (hertz / samplerate);
800 add_timer(&j->timer);
801 }
802
803 static void ixj_tone_timeout(IXJ *j)
804 {
805 IXJ_TONE ti;
806
807 j->tone_state++;
808 if (j->tone_state == 3) {
809 j->tone_state = 0;
810 if (j->cadence_t) {
811 j->tone_cadence_state++;
812 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
813 switch (j->cadence_t->termination) {
814 case PLAY_ONCE:
815 ixj_cpt_stop(j);
816 break;
817 case REPEAT_LAST_ELEMENT:
818 j->tone_cadence_state--;
819 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
820 break;
821 case REPEAT_ALL:
822 j->tone_cadence_state = 0;
823 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
824 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
825 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
826 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
827 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
828 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
829 ixj_init_tone(j, &ti);
830 }
831 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
832 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
833 ixj_play_tone(j, j->cadence_t->ce[0].index);
834 break;
835 }
836 } else {
837 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
838 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
839 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
840 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
841 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
842 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
843 ixj_init_tone(j, &ti);
844 }
845 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
846 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
847 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
848 }
849 }
850 }
851 }
852
853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
854 {
855 if(j->ixj_signals[event]) {
856 if(ixjdebug & 0x0100)
857 printk("Sending signal for event %d\n", event);
858 /* Send apps notice of change */
859 /* see config.h for macro definition */
860 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
861 }
862 }
863
864 static void ixj_pstn_state(IXJ *j)
865 {
866 int var;
867 union XOPXR0 XR0, daaint;
868
869 var = 10;
870
871 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
872 daaint.reg = 0;
873 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
874
875 j->pld_scrr.byte = inb_p(j->XILINXbase);
876 if (j->pld_scrr.bits.daaflag) {
877 daa_int_read(j);
878 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
879 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
880 daaint.bitreg.RING = 1;
881 if(ixjdebug & 0x0008) {
882 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
883 }
884 } else {
885 daa_set_mode(j, SOP_PU_RESET);
886 }
887 }
888 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
889 daaint.bitreg.Caller_ID = 1;
890 j->pstn_cid_intr = 1;
891 j->pstn_cid_received = jiffies;
892 if(ixjdebug & 0x0008) {
893 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
894 }
895 }
896 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
897 daaint.bitreg.Cadence = 1;
898 if(ixjdebug & 0x0008) {
899 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
900 }
901 }
902 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
903 daaint.bitreg.VDD_OK = 1;
904 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
905 }
906 }
907 daa_CR_read(j, 1);
908 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
909 daaint.bitreg.RMR = 1;
910 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
911 if(ixjdebug & 0x0008) {
912 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
913 }
914 j->pstn_prev_rmr = j->pstn_last_rmr;
915 j->pstn_last_rmr = jiffies;
916 }
917 switch(j->daa_mode) {
918 case SOP_PU_SLEEP:
919 if (daaint.bitreg.RING) {
920 if (!j->flags.pstn_ringing) {
921 if (j->daa_mode != SOP_PU_RINGING) {
922 j->pstn_ring_int = jiffies;
923 daa_set_mode(j, SOP_PU_RINGING);
924 }
925 }
926 }
927 break;
928 case SOP_PU_RINGING:
929 if (daaint.bitreg.RMR) {
930 if (ixjdebug & 0x0008) {
931 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
932 }
933 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
934 j->flags.pstn_rmr = 1;
935 j->pstn_ring_start = jiffies;
936 j->pstn_ring_stop = 0;
937 j->ex.bits.pstn_ring = 0;
938 if (j->cadence_f[4].state == 0) {
939 j->cadence_f[4].state = 1;
940 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
941 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
942 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
943 } else if (j->cadence_f[4].state == 2) {
944 if((time_after(jiffies, j->cadence_f[4].off1min) &&
945 time_before(jiffies, j->cadence_f[4].off1max))) {
946 if (j->cadence_f[4].on2) {
947 j->cadence_f[4].state = 3;
948 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
949 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
950 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
951 } else {
952 j->cadence_f[4].state = 7;
953 }
954 } else {
955 if (ixjdebug & 0x0008) {
956 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
957 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
958 j->cadence_f[4].off1);
959 }
960 j->cadence_f[4].state = 0;
961 }
962 } else if (j->cadence_f[4].state == 4) {
963 if((time_after(jiffies, j->cadence_f[4].off2min) &&
964 time_before(jiffies, j->cadence_f[4].off2max))) {
965 if (j->cadence_f[4].on3) {
966 j->cadence_f[4].state = 5;
967 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
968 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
969 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
970 } else {
971 j->cadence_f[4].state = 7;
972 }
973 } else {
974 if (ixjdebug & 0x0008) {
975 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
976 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
977 j->cadence_f[4].off2);
978 }
979 j->cadence_f[4].state = 0;
980 }
981 } else if (j->cadence_f[4].state == 6) {
982 if((time_after(jiffies, j->cadence_f[4].off3min) &&
983 time_before(jiffies, j->cadence_f[4].off3max))) {
984 j->cadence_f[4].state = 7;
985 } else {
986 if (ixjdebug & 0x0008) {
987 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
988 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
989 j->cadence_f[4].off3);
990 }
991 j->cadence_f[4].state = 0;
992 }
993 } else {
994 j->cadence_f[4].state = 0;
995 }
996 } else { /* Falling edge of RMR */
997 j->pstn_ring_start = 0;
998 j->pstn_ring_stop = jiffies;
999 if (j->cadence_f[4].state == 1) {
1000 if(!j->cadence_f[4].on1) {
1001 j->cadence_f[4].state = 7;
1002 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003 time_before(jiffies, j->cadence_f[4].on1max))) {
1004 if (j->cadence_f[4].off1) {
1005 j->cadence_f[4].state = 2;
1006 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009 } else {
1010 j->cadence_f[4].state = 7;
1011 }
1012 } else {
1013 if (ixjdebug & 0x0008) {
1014 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016 j->cadence_f[4].on1);
1017 }
1018 j->cadence_f[4].state = 0;
1019 }
1020 } else if (j->cadence_f[4].state == 3) {
1021 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022 time_before(jiffies, j->cadence_f[4].on2max))) {
1023 if (j->cadence_f[4].off2) {
1024 j->cadence_f[4].state = 4;
1025 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028 } else {
1029 j->cadence_f[4].state = 7;
1030 }
1031 } else {
1032 if (ixjdebug & 0x0008) {
1033 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035 j->cadence_f[4].on2);
1036 }
1037 j->cadence_f[4].state = 0;
1038 }
1039 } else if (j->cadence_f[4].state == 5) {
1040 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041 time_before(jiffies, j->cadence_f[4].on3max))) {
1042 if (j->cadence_f[4].off3) {
1043 j->cadence_f[4].state = 6;
1044 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 j->cadence_f[4].state = 0;
1052 }
1053 } else {
1054 if (ixjdebug & 0x0008) {
1055 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057 j->cadence_f[4].on3);
1058 }
1059 j->cadence_f[4].state = 0;
1060 }
1061 }
1062 if (ixjdebug & 0x0010) {
1063 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064 }
1065 if (ixjdebug & 0x0010) {
1066 switch(j->cadence_f[4].state) {
1067 case 1:
1068 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070 break;
1071 case 2:
1072 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074 break;
1075 case 3:
1076 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078 break;
1079 case 4:
1080 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082 break;
1083 case 5:
1084 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086 break;
1087 case 6:
1088 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090 break;
1091 }
1092 }
1093 }
1094 if (j->cadence_f[4].state == 7) {
1095 j->cadence_f[4].state = 0;
1096 j->pstn_ring_stop = jiffies;
1097 j->ex.bits.pstn_ring = 1;
1098 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099 if(ixjdebug & 0x0008) {
1100 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101 }
1102 }
1103 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105 if(ixjdebug & 0x0008) {
1106 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109 }
1110 j->pstn_ring_stop = j->pstn_ring_int = 0;
1111 daa_set_mode(j, SOP_PU_SLEEP);
1112 }
1113 outb_p(j->pld_scrw.byte, j->XILINXbase);
1114 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115 ixj_daa_cid_read(j);
1116 j->ex.bits.caller_id = 1;
1117 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118 j->pstn_cid_intr = 0;
1119 }
1120 if (daaint.bitreg.Cadence) {
1121 if(ixjdebug & 0x0008) {
1122 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123 }
1124 daa_set_mode(j, SOP_PU_SLEEP);
1125 j->ex.bits.pstn_ring = 0;
1126 }
1127 break;
1128 case SOP_PU_CONVERSATION:
1129 if (daaint.bitreg.VDD_OK) {
1130 if(!daaint.bitreg.SI_0) {
1131 if (!j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = jiffies;
1136 }
1137 } else {
1138 if (j->pstn_winkstart) {
1139 if(ixjdebug & 0x0008) {
1140 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141 }
1142 j->pstn_winkstart = 0;
1143 }
1144 }
1145 }
1146 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147 if(ixjdebug & 0x0008) {
1148 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149 }
1150 daa_set_mode(j, SOP_PU_SLEEP);
1151 j->pstn_winkstart = 0;
1152 j->ex.bits.pstn_wink = 1;
1153 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154 }
1155 break;
1156 }
1157 }
1158
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161 int board;
1162 unsigned long jifon;
1163 IXJ *j = (IXJ *)ptr;
1164 board = j->board;
1165
1166 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167 ixj_perfmon(j->timerchecks);
1168 j->hookstate = ixj_hookstate(j);
1169 if (j->tone_state) {
1170 if (!(j->hookstate)) {
1171 ixj_cpt_stop(j);
1172 if (j->m_hook) {
1173 j->m_hook = 0;
1174 j->ex.bits.hookstate = 1;
1175 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176 }
1177 clear_bit(board, &j->busyflags);
1178 ixj_add_timer(j);
1179 return;
1180 }
1181 if (j->tone_state == 1)
1182 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183 else
1184 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186 if (j->tone_state == 1) {
1187 ixj_play_tone(j, j->tone_index);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 } else {
1194 ixj_play_tone(j, 0);
1195 if (j->dsp.low == 0x20) {
1196 clear_bit(board, &j->busyflags);
1197 ixj_add_timer(j);
1198 return;
1199 }
1200 }
1201 } else {
1202 ixj_tone_timeout(j);
1203 if (j->flags.dialtone) {
1204 ixj_dialtone(j);
1205 }
1206 if (j->flags.busytone) {
1207 ixj_busytone(j);
1208 if (j->dsp.low == 0x20) {
1209 clear_bit(board, &j->busyflags);
1210 ixj_add_timer(j);
1211 return;
1212 }
1213 }
1214 if (j->flags.ringback) {
1215 ixj_ringback(j);
1216 if (j->dsp.low == 0x20) {
1217 clear_bit(board, &j->busyflags);
1218 ixj_add_timer(j);
1219 return;
1220 }
1221 }
1222 if (!j->tone_state) {
1223 ixj_cpt_stop(j);
1224 }
1225 }
1226 }
1227 if (!(j->tone_state && j->dsp.low == 0x20)) {
1228 if (IsRxReady(j)) {
1229 ixj_read_frame(j);
1230 }
1231 if (IsTxReady(j)) {
1232 ixj_write_frame(j);
1233 }
1234 }
1235 if (j->flags.cringing) {
1236 if (j->hookstate & 1) {
1237 j->flags.cringing = 0;
1238 ixj_ring_off(j);
1239 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240 switch(j->cadence_f[5].state) {
1241 case 0:
1242 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244 if(ixjdebug & 0x0004) {
1245 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246 }
1247 ixj_ring_on(j);
1248 }
1249 j->cadence_f[5].state = 1;
1250 break;
1251 case 1:
1252 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254 if(ixjdebug & 0x0004) {
1255 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256 }
1257 ixj_ring_off(j);
1258 j->cadence_f[5].state = 2;
1259 }
1260 break;
1261 case 2:
1262 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263 if(ixjdebug & 0x0004) {
1264 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265 }
1266 ixj_ring_on(j);
1267 if (j->cadence_f[5].on2) {
1268 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269 j->cadence_f[5].state = 3;
1270 } else {
1271 j->cadence_f[5].state = 7;
1272 }
1273 }
1274 break;
1275 case 3:
1276 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277 if(ixjdebug & 0x0004) {
1278 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279 }
1280 ixj_ring_off(j);
1281 if (j->cadence_f[5].off2) {
1282 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283 j->cadence_f[5].state = 4;
1284 } else {
1285 j->cadence_f[5].state = 7;
1286 }
1287 }
1288 break;
1289 case 4:
1290 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291 if(ixjdebug & 0x0004) {
1292 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293 }
1294 ixj_ring_on(j);
1295 if (j->cadence_f[5].on3) {
1296 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297 j->cadence_f[5].state = 5;
1298 } else {
1299 j->cadence_f[5].state = 7;
1300 }
1301 }
1302 break;
1303 case 5:
1304 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305 if(ixjdebug & 0x0004) {
1306 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307 }
1308 ixj_ring_off(j);
1309 if (j->cadence_f[5].off3) {
1310 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311 j->cadence_f[5].state = 6;
1312 } else {
1313 j->cadence_f[5].state = 7;
1314 }
1315 }
1316 break;
1317 case 6:
1318 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->cadence_f[5].state = 7;
1323 }
1324 break;
1325 case 7:
1326 if(ixjdebug & 0x0004) {
1327 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328 }
1329 j->flags.cidring = 1;
1330 j->cadence_f[5].state = 0;
1331 break;
1332 }
1333 if (j->flags.cidring && !j->flags.cidsent) {
1334 j->flags.cidsent = 1;
1335 if(j->fskdcnt) {
1336 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337 ixj_pre_cid(j);
1338 }
1339 j->flags.cidring = 0;
1340 }
1341 clear_bit(board, &j->busyflags);
1342 ixj_add_timer(j);
1343 return;
1344 } else {
1345 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346 if (j->flags.cidring && !j->flags.cidsent) {
1347 j->flags.cidsent = 1;
1348 if(j->fskdcnt) {
1349 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350 ixj_pre_cid(j);
1351 }
1352 j->flags.cidring = 0;
1353 }
1354 j->ring_cadence_t--;
1355 if (j->ring_cadence_t == -1)
1356 j->ring_cadence_t = 15;
1357 j->ring_cadence_jif = jiffies;
1358
1359 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361 j->flags.firstring = 1;
1362 else
1363 ixj_ring_on(j);
1364 } else {
1365 ixj_ring_off(j);
1366 if(!j->flags.cidsent)
1367 j->flags.cidring = 1;
1368 }
1369 }
1370 clear_bit(board, &j->busyflags);
1371 ixj_add_timer(j);
1372 return;
1373 }
1374 }
1375 if (!j->flags.ringing) {
1376 if (j->hookstate) { /* & 1) { */
1377 if (j->dsp.low != 0x20 &&
1378 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380 }
1381 LineMonitor(j);
1382 read_filters(j);
1383 ixj_WriteDSPCommand(0x511B, j);
1384 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385 if (!j->m_hook && (j->hookstate & 1)) {
1386 j->m_hook = j->ex.bits.hookstate = 1;
1387 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388 }
1389 } else {
1390 if (j->ex.bits.dtmf_ready) {
1391 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392 }
1393 if (j->m_hook) {
1394 j->m_hook = 0;
1395 j->ex.bits.hookstate = 1;
1396 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397 }
1398 }
1399 }
1400 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401 ixj_pstn_state(j);
1402 }
1403 if (j->ex.bytes) {
1404 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1405 }
1406 clear_bit(board, &j->busyflags);
1407 }
1408 ixj_add_timer(j);
1409 }
1410
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413 unsigned long jif;
1414
1415 jif = jiffies + ((60 * hertz) / 100);
1416 while (!IsStatusReady(j)) {
1417 ixj_perfmon(j->statuswait);
1418 if (time_after(jiffies, jif)) {
1419 ixj_perfmon(j->statuswaitfail);
1420 return -1;
1421 }
1422 }
1423 return 0;
1424 }
1425
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428 unsigned long jif;
1429
1430 jif = jiffies + ((60 * hertz) / 100);
1431 while (!IsPCControlReady(j)) {
1432 ixj_perfmon(j->pcontrolwait);
1433 if (time_after(jiffies, jif)) {
1434 ixj_perfmon(j->pcontrolwaitfail);
1435 return -1;
1436 }
1437 }
1438 return 0;
1439 }
1440
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443 BYTES bytes;
1444 unsigned long jif;
1445
1446 atomic_inc(&j->DSPWrite);
1447 if(atomic_read(&j->DSPWrite) > 1) {
1448 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449 return -1;
1450 }
1451 bytes.high = (cmd & 0xFF00) >> 8;
1452 bytes.low = cmd & 0x00FF;
1453 jif = jiffies + ((60 * hertz) / 100);
1454 while (!IsControlReady(j)) {
1455 ixj_perfmon(j->iscontrolready);
1456 if (time_after(jiffies, jif)) {
1457 ixj_perfmon(j->iscontrolreadyfail);
1458 atomic_dec(&j->DSPWrite);
1459 if(atomic_read(&j->DSPWrite) > 0) {
1460 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461 while(atomic_read(&j->DSPWrite) > 0) {
1462 atomic_dec(&j->DSPWrite);
1463 }
1464 }
1465 return -1;
1466 }
1467 }
1468 outb(bytes.low, j->DSPbase + 6);
1469 outb(bytes.high, j->DSPbase + 7);
1470
1471 if (ixj_status_wait(j)) {
1472 j->ssr.low = 0xFF;
1473 j->ssr.high = 0xFF;
1474 atomic_dec(&j->DSPWrite);
1475 if(atomic_read(&j->DSPWrite) > 0) {
1476 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477 while(atomic_read(&j->DSPWrite) > 0) {
1478 atomic_dec(&j->DSPWrite);
1479 }
1480 }
1481 return -1;
1482 }
1483 /* Read Software Status Register */
1484 j->ssr.low = inb_p(j->DSPbase + 2);
1485 j->ssr.high = inb_p(j->DSPbase + 3);
1486 atomic_dec(&j->DSPWrite);
1487 if(atomic_read(&j->DSPWrite) > 0) {
1488 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489 while(atomic_read(&j->DSPWrite) > 0) {
1490 atomic_dec(&j->DSPWrite);
1491 }
1492 }
1493 return 0;
1494 }
1495
1496 /***************************************************************************
1497 *
1498 * General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503 if (ixj_WriteDSPCommand(0x5143, j))
1504 return -1;
1505
1506 j->gpio.bytes.low = j->ssr.low;
1507 j->gpio.bytes.high = j->ssr.high;
1508
1509 return 0;
1510 }
1511
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514 if (j->cardtype == QTI_LINEJACK) {
1515 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520 outb(j->pld_scrw.byte, j->XILINXbase);
1521 }
1522 }
1523
1524 /*********************************************************************
1525 * GPIO Pins are configured as follows on the Quicknet Internet
1526 * PhoneJACK Telephony Cards
1527 *
1528 * POTS Select GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540 if (j->cardtype == QTI_PHONEJACK_LITE) {
1541 if (arg != PORT_POTS)
1542 return 10;
1543 else
1544 return 0;
1545 }
1546 switch (arg) {
1547 case PORT_POTS:
1548 j->port = PORT_POTS;
1549 switch (j->cardtype) {
1550 case QTI_PHONECARD:
1551 if (j->flags.pcmciasct == 1)
1552 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553 else
1554 return 11;
1555 break;
1556 case QTI_PHONEJACK_PCI:
1557 j->pld_slicw.pcib.mic = 0;
1558 j->pld_slicw.pcib.spk = 0;
1559 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560 break;
1561 case QTI_LINEJACK:
1562 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1563 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1564 Software Control Register */
1565 return 2;
1566 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1567
1568 outb(j->pld_scrw.byte, j->XILINXbase);
1569 j->pld_clock.byte = 0;
1570 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571 j->pld_slicw.bits.rly1 = 1;
1572 j->pld_slicw.bits.spken = 0;
1573 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1575 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1576 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1577 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1578 ixj_mixer(0x0E80, j); /*Mic mute */
1579 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1580 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1581 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1582 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584 break;
1585 case QTI_PHONEJACK:
1586 j->gpio.bytes.high = 0x0B;
1587 j->gpio.bits.gpio6 = 0;
1588 j->gpio.bits.gpio7 = 0;
1589 ixj_WriteDSPCommand(j->gpio.word, j);
1590 break;
1591 }
1592 break;
1593 case PORT_PSTN:
1594 if (j->cardtype == QTI_LINEJACK) {
1595 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597 j->pld_slicw.bits.rly3 = 0;
1598 j->pld_slicw.bits.rly1 = 1;
1599 j->pld_slicw.bits.spken = 0;
1600 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601 j->port = PORT_PSTN;
1602 } else {
1603 return 4;
1604 }
1605 break;
1606 case PORT_SPEAKER:
1607 j->port = PORT_SPEAKER;
1608 switch (j->cardtype) {
1609 case QTI_PHONECARD:
1610 if (j->flags.pcmciasct) {
1611 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612 }
1613 break;
1614 case QTI_PHONEJACK_PCI:
1615 j->pld_slicw.pcib.mic = 1;
1616 j->pld_slicw.pcib.spk = 1;
1617 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618 break;
1619 case QTI_LINEJACK:
1620 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1621 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1622 Software Control Register */
1623 return 2;
1624 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1625
1626 outb(j->pld_scrw.byte, j->XILINXbase);
1627 j->pld_clock.byte = 0;
1628 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629 j->pld_slicw.bits.rly1 = 1;
1630 j->pld_slicw.bits.spken = 1;
1631 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1633 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1634 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1635 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1636 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1637 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1638 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1639 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1640 break;
1641 case QTI_PHONEJACK:
1642 j->gpio.bytes.high = 0x0B;
1643 j->gpio.bits.gpio6 = 0;
1644 j->gpio.bits.gpio7 = 1;
1645 ixj_WriteDSPCommand(j->gpio.word, j);
1646 break;
1647 }
1648 break;
1649 case PORT_HANDSET:
1650 if (j->cardtype != QTI_PHONEJACK) {
1651 return 5;
1652 } else {
1653 j->gpio.bytes.high = 0x0B;
1654 j->gpio.bits.gpio6 = 1;
1655 j->gpio.bits.gpio7 = 0;
1656 ixj_WriteDSPCommand(j->gpio.word, j);
1657 j->port = PORT_HANDSET;
1658 }
1659 break;
1660 default:
1661 return 6;
1662 break;
1663 }
1664 return 0;
1665 }
1666
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669 if (j->cardtype == QTI_LINEJACK) {
1670 if (arg) {
1671 if (j->port == PORT_PSTN) {
1672 j->pld_slicw.bits.rly1 = 0;
1673 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674 j->flags.pots_pstn = 1;
1675 return 1;
1676 } else {
1677 j->flags.pots_pstn = 0;
1678 return 0;
1679 }
1680 } else {
1681 j->pld_slicw.bits.rly1 = 1;
1682 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683 j->flags.pots_pstn = 0;
1684 return 1;
1685 }
1686 } else {
1687 return 0;
1688 }
1689 }
1690
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694 {
1695 if (ixjdebug & 0x0004)
1696 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1697
1698 j->gpio.bytes.high = 0x0B;
1699 j->gpio.bytes.low = 0x00;
1700 j->gpio.bits.gpio1 = 1;
1701 j->gpio.bits.gpio2 = 1;
1702 j->gpio.bits.gpio5 = 0;
1703 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1704 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705 {
1706 if (ixjdebug & 0x0004)
1707 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710 }
1711 }
1712
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715 if(j->cardtype == QTI_PHONECARD){
1716 if(j->flags.pcmciascp){
1717 if(val == -1)
1718 return j->siadc.bits.rxg;
1719
1720 if(val < 0 || val > 0x1F)
1721 return -1;
1722
1723 j->siadc.bits.hom = 0; /* Handset Out Mute */
1724 j->siadc.bits.lom = 0; /* Line Out Mute */
1725 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1726 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1727 j->psccr.bits.rw = 0; /* Read / Write flag */
1728 j->psccr.bits.dev = 0;
1729 outb(j->siadc.byte, j->XILINXbase + 0x00);
1730 outb(j->psccr.byte, j->XILINXbase + 0x01);
1731 ixj_PCcontrol_wait(j);
1732 return j->siadc.bits.rxg;
1733 }
1734 }
1735 return -1;
1736 }
1737
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740 if(j->cardtype == QTI_PHONECARD){
1741 if(j->flags.pcmciascp){
1742 if(val == -1)
1743 return j->sidac.bits.txg;
1744
1745 if(val < 0 || val > 0x1F)
1746 return -1;
1747
1748 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1749 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1750 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1751 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1752 j->psccr.bits.rw = 0; /* Read / Write flag */
1753 j->psccr.bits.dev = 0;
1754 outb(j->sidac.byte, j->XILINXbase + 0x00);
1755 outb(j->psccr.byte, j->XILINXbase + 0x01);
1756 ixj_PCcontrol_wait(j);
1757 return j->sidac.bits.txg;
1758 }
1759 }
1760 return -1;
1761 }
1762
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766 if (!j->flags.pcmciastate) {
1767 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769 j->flags.pcmciastate = 4;
1770 return 0;
1771 }
1772 if (j->pccr1.bits.ed) {
1773 j->pccr1.bits.ed = 0;
1774 j->psccr.bits.dev = 3;
1775 j->psccr.bits.rw = 1;
1776 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777 ixj_PCcontrol_wait(j);
1778 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780 j->psccr.bits.dev = 3;
1781 j->psccr.bits.rw = 0;
1782 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783 ixj_PCcontrol_wait(j);
1784 return j->pslic.bits.led2 ? 1 : 0;
1785 } else if (j->flags.pcmciasct) {
1786 return j->r_hook;
1787 } else {
1788 return 1;
1789 }
1790 } else if (j->flags.pcmciastate == 4) {
1791 if (!j->pccr1.bits.drf) {
1792 j->flags.pcmciastate = 3;
1793 }
1794 return 0;
1795 } else if (j->flags.pcmciastate == 3) {
1796 j->pccr2.bits.pwr = 0;
1797 j->pccr2.bits.rstc = 1;
1798 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799 j->checkwait = jiffies + (hertz * 2);
1800 j->flags.incheck = 1;
1801 j->flags.pcmciastate = 2;
1802 return 0;
1803 } else if (j->flags.pcmciastate == 2) {
1804 if (j->flags.incheck) {
1805 if (time_before(jiffies, j->checkwait)) {
1806 return 0;
1807 } else {
1808 j->flags.incheck = 0;
1809 }
1810 }
1811 j->pccr2.bits.pwr = 0;
1812 j->pccr2.bits.rstc = 0;
1813 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814 j->flags.pcmciastate = 1;
1815 return 0;
1816 } else if (j->flags.pcmciastate == 1) {
1817 j->flags.pcmciastate = 0;
1818 if (!j->pccr1.bits.drf) {
1819 j->psccr.bits.dev = 3;
1820 j->psccr.bits.rw = 1;
1821 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822 ixj_PCcontrol_wait(j);
1823 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1824
1825 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1826
1827 if (j->flags.pcmciasct == 3) {
1828 j->flags.pcmciastate = 4;
1829 return 0;
1830 } else if (j->flags.pcmciasct == 0) {
1831 j->pccr2.bits.pwr = 1;
1832 j->pccr2.bits.rstc = 0;
1833 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834 j->port = PORT_SPEAKER;
1835 } else {
1836 j->port = PORT_POTS;
1837 }
1838 j->sic1.bits.cpd = 0; /* Chip Power Down */
1839 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1840 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1841 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1842 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1843 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1844 j->psccr.bits.rw = 0; /* Read / Write flag */
1845 j->psccr.bits.dev = 0;
1846 outb(j->sic1.byte, j->XILINXbase + 0x00);
1847 outb(j->psccr.byte, j->XILINXbase + 0x01);
1848 ixj_PCcontrol_wait(j);
1849
1850 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1851 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1852 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1853 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1854 j->sic2.bits.hpd = 0; /* HPF disable */
1855 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(j->sic2.byte, j->XILINXbase + 0x00);
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1870 j->psccr.bits.rw = 0; /* Read / Write flag */
1871 j->psccr.bits.dev = 0;
1872 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1873 outb(j->psccr.byte, j->XILINXbase + 0x01);
1874 ixj_PCcontrol_wait(j);
1875
1876 j->sirxg.bits.lig = 1; /* Line In Gain */
1877 j->sirxg.bits.lim = 1; /* Line In Mute */
1878 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1879 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1880 j->sirxg.bits.him = 0; /* Handset In Mute */
1881 j->sirxg.bits.iir = 1; /* IIR */
1882 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1883 j->psccr.bits.rw = 0; /* Read / Write flag */
1884 j->psccr.bits.dev = 0;
1885 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886 outb(j->psccr.byte, j->XILINXbase + 0x01);
1887 ixj_PCcontrol_wait(j);
1888
1889 ixj_siadc(j, 0x17);
1890 ixj_sidac(j, 0x1D);
1891
1892 j->siaatt.bits.sot = 0;
1893 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1894 j->psccr.bits.rw = 0; /* Read / Write flag */
1895 j->psccr.bits.dev = 0;
1896 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897 outb(j->psccr.byte, j->XILINXbase + 0x01);
1898 ixj_PCcontrol_wait(j);
1899
1900 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901 j->psccr.byte = j->pslic.byte = 0;
1902 j->pslic.bits.powerdown = 1;
1903 j->psccr.bits.dev = 3;
1904 j->psccr.bits.rw = 0;
1905 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906 ixj_PCcontrol_wait(j);
1907 }
1908 }
1909 return 0;
1910 } else {
1911 j->flags.pcmciascp = 0;
1912 return 0;
1913 }
1914 return 0;
1915 }
1916
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919 int fOffHook = 0;
1920
1921 switch (j->cardtype) {
1922 case QTI_PHONEJACK:
1923 ixj_gpio_read(j);
1924 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925 break;
1926 case QTI_LINEJACK:
1927 case QTI_PHONEJACK_LITE:
1928 case QTI_PHONEJACK_PCI:
1929 SLIC_GetState(j);
1930 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932 if(fOffHook != j->p_hook) {
1933 if(!j->checkwait) {
1934 j->checkwait = jiffies;
1935 }
1936 if(time_before(jiffies, j->checkwait + 2)) {
1937 fOffHook ^= 1;
1938 } else {
1939 j->checkwait = 0;
1940 }
1941 j->p_hook = fOffHook;
1942 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943 }
1944 } else {
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947 if (j->flags.ringing || j->flags.cringing) {
1948 if (!in_interrupt()) {
1949 msleep(20);
1950 }
1951 SLIC_GetState(j);
1952 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953 ixj_ring_on(j);
1954 }
1955 }
1956 if (j->cardtype == QTI_PHONEJACK_PCI) {
1957 j->pld_scrr.byte = inb_p(j->XILINXbase);
1958 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959 } else
1960 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961 }
1962 }
1963 break;
1964 case QTI_PHONECARD:
1965 fOffHook = ixj_pcmcia_cable_check(j);
1966 break;
1967 }
1968 if (j->r_hook != fOffHook) {
1969 j->r_hook = fOffHook;
1970 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971 j->ex.bits.hookstate = 1;
1972 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973 } else if (!fOffHook) {
1974 j->flash_end = jiffies + ((60 * hertz) / 100);
1975 }
1976 }
1977 if (fOffHook) {
1978 if(time_before(jiffies, j->flash_end)) {
1979 j->ex.bits.flash = 1;
1980 j->flash_end = 0;
1981 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982 }
1983 } else {
1984 if(time_before(jiffies, j->flash_end)) {
1985 fOffHook = 1;
1986 }
1987 }
1988
1989 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990 fOffHook |= 2;
1991
1992 if (j->port == PORT_SPEAKER) {
1993 if(j->cardtype == QTI_PHONECARD) {
1994 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995 fOffHook |= 2;
1996 }
1997 } else {
1998 fOffHook |= 2;
1999 }
2000 }
2001
2002 if (j->port == PORT_HANDSET)
2003 fOffHook |= 2;
2004
2005 return fOffHook;
2006 }
2007
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011 {
2012 if (ixjdebug & 0x0004)
2013 printk(KERN_INFO "IXJ Ring Off\n");
2014 j->gpio.bytes.high = 0x0B;
2015 j->gpio.bytes.low = 0x00;
2016 j->gpio.bits.gpio1 = 0;
2017 j->gpio.bits.gpio2 = 1;
2018 j->gpio.bits.gpio5 = 0;
2019 ixj_WriteDSPCommand(j->gpio.word, j);
2020 } else /* Internet LineJACK */
2021 {
2022 if (ixjdebug & 0x0004)
2023 printk(KERN_INFO "IXJ Ring Off\n");
2024
2025 if(!j->flags.cidplay)
2026 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028 SLIC_GetState(j);
2029 }
2030 }
2031
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034 j->flags.cringing = 1;
2035 if (ixjdebug & 0x0004)
2036 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037 if (ixj_hookstate(j) & 1) {
2038 if (j->port == PORT_POTS)
2039 ixj_ring_off(j);
2040 j->flags.cringing = 0;
2041 if (ixjdebug & 0x0004)
2042 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044 j->ring_cadence_jif = jiffies;
2045 j->flags.cidsent = j->flags.cidring = 0;
2046 j->cadence_f[5].state = 0;
2047 if(j->cadence_f[5].on1)
2048 ixj_ring_on(j);
2049 } else {
2050 j->ring_cadence_jif = jiffies;
2051 j->ring_cadence_t = 15;
2052 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053 ixj_ring_on(j);
2054 } else {
2055 ixj_ring_off(j);
2056 }
2057 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058 }
2059 }
2060
2061 static int ixj_ring(IXJ *j)
2062 {
2063 char cntr;
2064 unsigned long jif;
2065
2066 j->flags.ringing = 1;
2067 if (ixj_hookstate(j) & 1) {
2068 ixj_ring_off(j);
2069 j->flags.ringing = 0;
2070 return 1;
2071 }
2072 for (cntr = 0; cntr < j->maxrings; cntr++) {
2073 jif = jiffies + (1 * hertz);
2074 ixj_ring_on(j);
2075 while (time_before(jiffies, jif)) {
2076 if (ixj_hookstate(j) & 1) {
2077 ixj_ring_off(j);
2078 j->flags.ringing = 0;
2079 return 1;
2080 }
2081 schedule_timeout_interruptible(1);
2082 if (signal_pending(current))
2083 break;
2084 }
2085 jif = jiffies + (3 * hertz);
2086 ixj_ring_off(j);
2087 while (time_before(jiffies, jif)) {
2088 if (ixj_hookstate(j) & 1) {
2089 msleep(10);
2090 if (ixj_hookstate(j) & 1) {
2091 j->flags.ringing = 0;
2092 return 1;
2093 }
2094 }
2095 schedule_timeout_interruptible(1);
2096 if (signal_pending(current))
2097 break;
2098 }
2099 }
2100 ixj_ring_off(j);
2101 j->flags.ringing = 0;
2102 return 0;
2103 }
2104
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107 IXJ *j = get_ixj(p->board);
2108 file_p->private_data = j;
2109
2110 if (!j->DSPbase)
2111 return -ENODEV;
2112
2113 if (file_p->f_mode & FMODE_READ) {
2114 if(!j->readers) {
2115 j->readers++;
2116 } else {
2117 return -EBUSY;
2118 }
2119 }
2120
2121 if (file_p->f_mode & FMODE_WRITE) {
2122 if(!j->writers) {
2123 j->writers++;
2124 } else {
2125 if (file_p->f_mode & FMODE_READ){
2126 j->readers--;
2127 }
2128 return -EBUSY;
2129 }
2130 }
2131
2132 if (j->cardtype == QTI_PHONECARD) {
2133 j->pslic.bits.powerdown = 0;
2134 j->psccr.bits.dev = 3;
2135 j->psccr.bits.rw = 0;
2136 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137 ixj_PCcontrol_wait(j);
2138 }
2139
2140 j->flags.cidplay = 0;
2141 j->flags.cidcw_ack = 0;
2142
2143 if (ixjdebug & 0x0002)
2144 printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146 j->framesread = j->frameswritten = 0;
2147 return 0;
2148 }
2149
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152 IXJ_TONE ti;
2153 int cnt;
2154 IXJ *j = file_p->private_data;
2155 int board = j->p.board;
2156
2157 /*
2158 * Set up locks to ensure that only one process is talking to the DSP at a time.
2159 * This is necessary to keep the DSP from locking up.
2160 */
2161 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162 schedule_timeout_interruptible(1);
2163 if (ixjdebug & 0x0002)
2164 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166 if (j->cardtype == QTI_PHONECARD)
2167 ixj_set_port(j, PORT_SPEAKER);
2168 else
2169 ixj_set_port(j, PORT_POTS);
2170
2171 aec_stop(j);
2172 ixj_play_stop(j);
2173 ixj_record_stop(j);
2174 set_play_volume(j, 0x100);
2175 set_rec_volume(j, 0x100);
2176 ixj_ring_off(j);
2177
2178 /* Restore the tone table to default settings. */
2179 ti.tone_index = 10;
2180 ti.gain0 = 1;
2181 ti.freq0 = hz941;
2182 ti.gain1 = 0;
2183 ti.freq1 = hz1209;
2184 ixj_init_tone(j, &ti);
2185 ti.tone_index = 11;
2186 ti.gain0 = 1;
2187 ti.freq0 = hz941;
2188 ti.gain1 = 0;
2189 ti.freq1 = hz1336;
2190 ixj_init_tone(j, &ti);
2191 ti.tone_index = 12;
2192 ti.gain0 = 1;
2193 ti.freq0 = hz941;
2194 ti.gain1 = 0;
2195 ti.freq1 = hz1477;
2196 ixj_init_tone(j, &ti);
2197 ti.tone_index = 13;
2198 ti.gain0 = 1;
2199 ti.freq0 = hz800;
2200 ti.gain1 = 0;
2201 ti.freq1 = 0;
2202 ixj_init_tone(j, &ti);
2203 ti.tone_index = 14;
2204 ti.gain0 = 1;
2205 ti.freq0 = hz1000;
2206 ti.gain1 = 0;
2207 ti.freq1 = 0;
2208 ixj_init_tone(j, &ti);
2209 ti.tone_index = 15;
2210 ti.gain0 = 1;
2211 ti.freq0 = hz1250;
2212 ti.gain1 = 0;
2213 ti.freq1 = 0;
2214 ixj_init_tone(j, &ti);
2215 ti.tone_index = 16;
2216 ti.gain0 = 1;
2217 ti.freq0 = hz950;
2218 ti.gain1 = 0;
2219 ti.freq1 = 0;
2220 ixj_init_tone(j, &ti);
2221 ti.tone_index = 17;
2222 ti.gain0 = 1;
2223 ti.freq0 = hz1100;
2224 ti.gain1 = 0;
2225 ti.freq1 = 0;
2226 ixj_init_tone(j, &ti);
2227 ti.tone_index = 18;
2228 ti.gain0 = 1;
2229 ti.freq0 = hz1400;
2230 ti.gain1 = 0;
2231 ti.freq1 = 0;
2232 ixj_init_tone(j, &ti);
2233 ti.tone_index = 19;
2234 ti.gain0 = 1;
2235 ti.freq0 = hz1500;
2236 ti.gain1 = 0;
2237 ti.freq1 = 0;
2238 ixj_init_tone(j, &ti);
2239 ti.tone_index = 20;
2240 ti.gain0 = 1;
2241 ti.freq0 = hz1600;
2242 ti.gain1 = 0;
2243 ti.freq1 = 0;
2244 ixj_init_tone(j, &ti);
2245 ti.tone_index = 21;
2246 ti.gain0 = 1;
2247 ti.freq0 = hz1800;
2248 ti.gain1 = 0;
2249 ti.freq1 = 0;
2250 ixj_init_tone(j, &ti);
2251 ti.tone_index = 22;
2252 ti.gain0 = 1;
2253 ti.freq0 = hz2100;
2254 ti.gain1 = 0;
2255 ti.freq1 = 0;
2256 ixj_init_tone(j, &ti);
2257 ti.tone_index = 23;
2258 ti.gain0 = 1;
2259 ti.freq0 = hz1300;
2260 ti.gain1 = 0;
2261 ti.freq1 = 0;
2262 ixj_init_tone(j, &ti);
2263 ti.tone_index = 24;
2264 ti.gain0 = 1;
2265 ti.freq0 = hz2450;
2266 ti.gain1 = 0;
2267 ti.freq1 = 0;
2268 ixj_init_tone(j, &ti);
2269 ti.tone_index = 25;
2270 ti.gain0 = 1;
2271 ti.freq0 = hz350;
2272 ti.gain1 = 0;
2273 ti.freq1 = hz440;
2274 ixj_init_tone(j, &ti);
2275 ti.tone_index = 26;
2276 ti.gain0 = 1;
2277 ti.freq0 = hz440;
2278 ti.gain1 = 0;
2279 ti.freq1 = hz480;
2280 ixj_init_tone(j, &ti);
2281 ti.tone_index = 27;
2282 ti.gain0 = 1;
2283 ti.freq0 = hz480;
2284 ti.gain1 = 0;
2285 ti.freq1 = hz620;
2286 ixj_init_tone(j, &ti);
2287
2288 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2289
2290 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2291
2292 j->ex.bits.dtmf_ready = 0;
2293 j->dtmf_state = 0;
2294 j->dtmf_wp = j->dtmf_rp = 0;
2295 j->rec_mode = j->play_mode = -1;
2296 j->flags.ringing = 0;
2297 j->maxrings = MAXRINGS;
2298 j->ring_cadence = USA_RING_CADENCE;
2299 if(j->cadence_f[5].enable) {
2300 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301 }
2302 j->drybuffer = 0;
2303 j->winktime = 320;
2304 j->flags.dtmf_oob = 0;
2305 for (cnt = 0; cnt < 4; cnt++)
2306 j->cadence_f[cnt].enable = 0;
2307
2308 idle(j);
2309
2310 if(j->cardtype == QTI_PHONECARD) {
2311 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312 }
2313
2314 if (file_p->f_mode & FMODE_READ)
2315 j->readers--;
2316 if (file_p->f_mode & FMODE_WRITE)
2317 j->writers--;
2318
2319 if (j->read_buffer && !j->readers) {
2320 kfree(j->read_buffer);
2321 j->read_buffer = NULL;
2322 j->read_buffer_size = 0;
2323 }
2324 if (j->write_buffer && !j->writers) {
2325 kfree(j->write_buffer);
2326 j->write_buffer = NULL;
2327 j->write_buffer_size = 0;
2328 }
2329 j->rec_codec = j->play_codec = 0;
2330 j->rec_frame_size = j->play_frame_size = 0;
2331 j->flags.cidsent = j->flags.cidring = 0;
2332
2333 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334 ixj_set_port(j, PORT_PSTN);
2335 daa_set_mode(j, SOP_PU_SLEEP);
2336 ixj_set_pots(j, 1);
2337 }
2338 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340 /* Set up the default signals for events */
2341 for (cnt = 0; cnt < 35; cnt++)
2342 j->ixj_signals[cnt] = SIGIO;
2343
2344 /* Set the excetion signal enable flags */
2345 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346 j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347 j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349 file_p->private_data = NULL;
2350 clear_bit(board, &j->busyflags);
2351 return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356 unsigned short fc, cnt, trg;
2357 int var;
2358
2359 trg = 0;
2360 if (ixj_WriteDSPCommand(0x5144, j)) {
2361 if(ixjdebug & 0x0001) {
2362 printk(KERN_INFO "Read Frame Counter failed!\n");
2363 }
2364 return -1;
2365 }
2366 fc = j->ssr.high << 8 | j->ssr.low;
2367 if (fc == j->frame_count)
2368 return 1;
2369
2370 j->frame_count = fc;
2371
2372 if (j->dtmf_proc)
2373 return 1;
2374
2375 var = 10;
2376
2377 for (cnt = 0; cnt < 4; cnt++) {
2378 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381 }
2382 return -1;
2383 }
2384 if (ixj_WriteDSPCommand(0x515C, j)) {
2385 if(ixjdebug & 0x0001) {
2386 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387 }
2388 return -1;
2389 }
2390 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392 if (j->cadence_f[cnt].enable) {
2393 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394 if (j->cadence_f[cnt].state == 0) {
2395 j->cadence_f[cnt].state = 1;
2396 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399 } else if (j->cadence_f[cnt].state == 2 &&
2400 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402 if (j->cadence_f[cnt].on2) {
2403 j->cadence_f[cnt].state = 3;
2404 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407 } else {
2408 j->cadence_f[cnt].state = 7;
2409 }
2410 } else if (j->cadence_f[cnt].state == 4 &&
2411 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413 if (j->cadence_f[cnt].on3) {
2414 j->cadence_f[cnt].state = 5;
2415 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418 } else {
2419 j->cadence_f[cnt].state = 7;
2420 }
2421 } else {
2422 j->cadence_f[cnt].state = 0;
2423 }
2424 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425 if (j->cadence_f[cnt].state == 1) {
2426 if(!j->cadence_f[cnt].on1) {
2427 j->cadence_f[cnt].state = 7;
2428 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430 if(j->cadence_f[cnt].off1) {
2431 j->cadence_f[cnt].state = 2;
2432 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435 } else {
2436 j->cadence_f[cnt].state = 7;
2437 }
2438 } else {
2439 j->cadence_f[cnt].state = 0;
2440 }
2441 } else if (j->cadence_f[cnt].state == 3) {
2442 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444 if(j->cadence_f[cnt].off2) {
2445 j->cadence_f[cnt].state = 4;
2446 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449 } else {
2450 j->cadence_f[cnt].state = 7;
2451 }
2452 } else {
2453 j->cadence_f[cnt].state = 0;
2454 }
2455 } else if (j->cadence_f[cnt].state == 5) {
2456 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458 if(j->cadence_f[cnt].off3) {
2459 j->cadence_f[cnt].state = 6;
2460 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463 } else {
2464 j->cadence_f[cnt].state = 7;
2465 }
2466 } else {
2467 j->cadence_f[cnt].state = 0;
2468 }
2469 } else {
2470 j->cadence_f[cnt].state = 0;
2471 }
2472 } else {
2473 switch(j->cadence_f[cnt].state) {
2474 case 1:
2475 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476 !j->cadence_f[cnt].off1 &&
2477 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479 j->cadence_f[cnt].state = 7;
2480 }
2481 break;
2482 case 3:
2483 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484 !j->cadence_f[cnt].off2 &&
2485 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486 j->cadence_f[cnt].state = 7;
2487 }
2488 break;
2489 case 5:
2490 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491 !j->cadence_f[cnt].off3) {
2492 j->cadence_f[cnt].state = 7;
2493 }
2494 break;
2495 }
2496 }
2497
2498 if (ixjdebug & 0x0040) {
2499 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500 switch(j->cadence_f[cnt].state) {
2501 case 0:
2502 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503 break;
2504 case 1:
2505 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507 break;
2508 case 2:
2509 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510 j->cadence_f[cnt].off1max);
2511 break;
2512 case 3:
2513 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514 j->cadence_f[cnt].on2max);
2515 break;
2516 case 4:
2517 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518 j->cadence_f[cnt].off2max);
2519 break;
2520 case 5:
2521 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522 j->cadence_f[cnt].on3max);
2523 break;
2524 case 6:
2525 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526 j->cadence_f[cnt].off3max);
2527 break;
2528 }
2529 }
2530 }
2531 if (j->cadence_f[cnt].state == 7) {
2532 j->cadence_f[cnt].state = 0;
2533 if (j->cadence_f[cnt].enable == 1)
2534 j->cadence_f[cnt].enable = 0;
2535 switch (cnt) {
2536 case 0:
2537 if(ixjdebug & 0x0020) {
2538 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539 }
2540 j->ex.bits.fc0 = 1;
2541 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542 break;
2543 case 1:
2544 if(ixjdebug & 0x0020) {
2545 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546 }
2547 j->ex.bits.fc1 = 1;
2548 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549 break;
2550 case 2:
2551 if(ixjdebug & 0x0020) {
2552 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553 }
2554 j->ex.bits.fc2 = 1;
2555 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556 break;
2557 case 3:
2558 if(ixjdebug & 0x0020) {
2559 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560 }
2561 j->ex.bits.fc3 = 1;
2562 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563 break;
2564 }
2565 }
2566 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569 trg = 1;
2570 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571 trg = 0;
2572 }
2573 switch (cnt) {
2574 case 0:
2575 if(ixjdebug & 0x0020) {
2576 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577 }
2578 j->ex.bits.f0 = 1;
2579 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580 break;
2581 case 1:
2582 if(ixjdebug & 0x0020) {
2583 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584 }
2585 j->ex.bits.f1 = 1;
2586 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587 break;
2588 case 2:
2589 if(ixjdebug & 0x0020) {
2590 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591 }
2592 j->ex.bits.f2 = 1;
2593 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594 break;
2595 case 3:
2596 if(ixjdebug & 0x0020) {
2597 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598 }
2599 j->ex.bits.f3 = 1;
2600 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601 break;
2602 }
2603 }
2604 }
2605 return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610 if (j->dtmf_proc) {
2611 return -1;
2612 }
2613 j->dtmf_proc = 1;
2614
2615 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2616 return -1;
2617
2618 j->dtmf.bytes.high = j->ssr.high;
2619 j->dtmf.bytes.low = j->ssr.low;
2620 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621 j->dtmf_state = 1;
2622 j->dtmf_current = j->dtmf.bits.digit;
2623 }
2624 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2625 {
2626 if(!j->cidcw_wait) {
2627 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628 j->dtmf_wp++;
2629 if (j->dtmf_wp == 79)
2630 j->dtmf_wp = 0;
2631 j->ex.bits.dtmf_ready = 1;
2632 if(j->ex_sig.bits.dtmf_ready) {
2633 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634 }
2635 }
2636 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637 if(ixjdebug & 0x0020) {
2638 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639 }
2640 j->flags.cidcw_ack = 1;
2641 }
2642 j->dtmf_state = 0;
2643 }
2644 j->dtmf_proc = 0;
2645
2646 return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657 static unsigned char table_ulaw2alaw[] =
2658 {
2659 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691 };
2692
2693 while (len--)
2694 {
2695 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696 buff++;
2697 }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702 static unsigned char table_alaw2ulaw[] =
2703 {
2704 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736 };
2737
2738 while (len--)
2739 {
2740 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741 buff++;
2742 }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747 unsigned long i = *ppos;
2748 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750 DECLARE_WAITQUEUE(wait, current);
2751
2752 if (j->flags.inread)
2753 return -EALREADY;
2754
2755 j->flags.inread = 1;
2756
2757 add_wait_queue(&j->read_q, &wait);
2758 set_current_state(TASK_INTERRUPTIBLE);
2759 mb();
2760
2761 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762 ++j->read_wait;
2763 if (file_p->f_flags & O_NONBLOCK) {
2764 set_current_state(TASK_RUNNING);
2765 remove_wait_queue(&j->read_q, &wait);
2766 j->flags.inread = 0;
2767 return -EAGAIN;
2768 }
2769 if (!ixj_hookstate(j)) {
2770 set_current_state(TASK_RUNNING);
2771 remove_wait_queue(&j->read_q, &wait);
2772 j->flags.inread = 0;
2773 return 0;
2774 }
2775 interruptible_sleep_on(&j->read_q);
2776 if (signal_pending(current)) {
2777 set_current_state(TASK_RUNNING);
2778 remove_wait_queue(&j->read_q, &wait);
2779 j->flags.inread = 0;
2780 return -EINTR;
2781 }
2782 }
2783
2784 remove_wait_queue(&j->read_q, &wait);
2785 set_current_state(TASK_RUNNING);
2786 /* Don't ever copy more than the user asks */
2787 if(j->rec_codec == ALAW)
2788 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790 j->read_buffer_ready = 0;
2791 if (i) {
2792 j->flags.inread = 0;
2793 return -EFAULT;
2794 } else {
2795 j->flags.inread = 0;
2796 return min(length, j->read_buffer_size);
2797 }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801 loff_t * ppos)
2802 {
2803 int pre_retval;
2804 ssize_t read_retval = 0;
2805 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807 pre_retval = ixj_PreRead(j, 0L);
2808 switch (pre_retval) {
2809 case NORMAL:
2810 read_retval = ixj_read(file_p, buf, length, ppos);
2811 ixj_PostRead(j, 0L);
2812 break;
2813 case NOPOST:
2814 read_retval = ixj_read(file_p, buf, length, ppos);
2815 break;
2816 case POSTONLY:
2817 ixj_PostRead(j, 0L);
2818 break;
2819 default:
2820 read_retval = pre_retval;
2821 }
2822 return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827 unsigned long i = *ppos;
2828 IXJ *j = file_p->private_data;
2829
2830 DECLARE_WAITQUEUE(wait, current);
2831
2832 if (j->flags.inwrite)
2833 return -EALREADY;
2834
2835 j->flags.inwrite = 1;
2836
2837 add_wait_queue(&j->write_q, &wait);
2838 set_current_state(TASK_INTERRUPTIBLE);
2839 mb();
2840
2841
2842 while (!j->write_buffers_empty) {
2843 ++j->write_wait;
2844 if (file_p->f_flags & O_NONBLOCK) {
2845 set_current_state(TASK_RUNNING);
2846 remove_wait_queue(&j->write_q, &wait);
2847 j->flags.inwrite = 0;
2848 return -EAGAIN;
2849 }
2850 if (!ixj_hookstate(j)) {
2851 set_current_state(TASK_RUNNING);
2852 remove_wait_queue(&j->write_q, &wait);
2853 j->flags.inwrite = 0;
2854 return 0;
2855 }
2856 interruptible_sleep_on(&j->write_q);
2857 if (signal_pending(current)) {
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 j->flags.inwrite = 0;
2861 return -EINTR;
2862 }
2863 }
2864 set_current_state(TASK_RUNNING);
2865 remove_wait_queue(&j->write_q, &wait);
2866 if (j->write_buffer_wp + count >= j->write_buffer_end)
2867 j->write_buffer_wp = j->write_buffer;
2868 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869 if (i) {
2870 j->flags.inwrite = 0;
2871 return -EFAULT;
2872 }
2873 if(j->play_codec == ALAW)
2874 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875 j->flags.inwrite = 0;
2876 return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881 int pre_retval;
2882 ssize_t write_retval = 0;
2883
2884 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886 pre_retval = ixj_PreWrite(j, 0L);
2887 switch (pre_retval) {
2888 case NORMAL:
2889 write_retval = ixj_write(file_p, buf, count, ppos);
2890 if (write_retval > 0) {
2891 ixj_PostWrite(j, 0L);
2892 j->write_buffer_wp += write_retval;
2893 j->write_buffers_empty--;
2894 }
2895 break;
2896 case NOPOST:
2897 write_retval = ixj_write(file_p, buf, count, ppos);
2898 if (write_retval > 0) {
2899 j->write_buffer_wp += write_retval;
2900 j->write_buffers_empty--;
2901 }
2902 break;
2903 case POSTONLY:
2904 ixj_PostWrite(j, 0L);
2905 break;
2906 default:
2907 write_retval = pre_retval;
2908 }
2909 return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914 int cnt, dly;
2915
2916 if (j->read_buffer) {
2917 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918 if (!(cnt % 16) && !IsRxReady(j)) {
2919 dly = 0;
2920 while (!IsRxReady(j)) {
2921 if (dly++ > 5) {
2922 dly = 0;
2923 break;
2924 }
2925 udelay(10);
2926 }
2927 }
2928 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930 inb_p(j->DSPbase + 0x0E);
2931 inb_p(j->DSPbase + 0x0F);
2932 }
2933 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935 }
2936 ++j->framesread;
2937 if (j->intercom != -1) {
2938 if (IsTxReady(get_ixj(j->intercom))) {
2939 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940 if (!(cnt % 16) && !IsTxReady(j)) {
2941 dly = 0;
2942 while (!IsTxReady(j)) {
2943 if (dly++ > 5) {
2944 dly = 0;
2945 break;
2946 }
2947 udelay(10);
2948 }
2949 }
2950 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952 }
2953 get_ixj(j->intercom)->frameswritten++;
2954 }
2955 } else {
2956 j->read_buffer_ready = 1;
2957 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2958
2959 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2960
2961 if(j->ixj_signals[SIG_READ_READY])
2962 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963 }
2964 }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969 {
2970 {
2971 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973 },
2974 {
2975 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977 },
2978 {
2979 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981 },
2982 {
2983 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985 },
2986 {
2987 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989 },
2990 {
2991 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993 }
2994 },
2995 {
2996 {
2997 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999 },
3000 {
3001 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003 },
3004 {
3005 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007 },
3008 {
3009 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011 },
3012 {
3013 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015 },
3016 {
3017 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019 }
3020 }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026 while (j->fskcnt < 20) {
3027 if(j->fskdcnt < (j->fsksize - 1))
3028 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030 j->fskcnt += 3;
3031 }
3032 j->fskcnt %= 20;
3033
3034 if (!bit)
3035 j->fskz++;
3036 if (j->fskz >= 6)
3037 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043 IXJ_CBYTE cb;
3044
3045 cb.cbyte = byte;
3046 ixj_write_cid_bit(j, 0);
3047 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060 int cnt;
3061
3062 for (cnt = 0; cnt < 150; cnt++) {
3063 ixj_write_cid_bit(j, 0);
3064 ixj_write_cid_bit(j, 1);
3065 }
3066 for (cnt = 0; cnt < 180; cnt++) {
3067 ixj_write_cid_bit(j, 1);
3068 }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073 int cnt;
3074
3075 for (cnt = 0; cnt < 80; cnt++) {
3076 ixj_write_cid_bit(j, 1);
3077 }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082 int cnt;
3083
3084 for (cnt = 0; cnt < strlen(s); cnt++) {
3085 ixj_write_cid_byte(j, s[cnt]);
3086 checksum = (checksum + s[cnt]);
3087 }
3088 return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093 int cnt;
3094
3095 for (cnt = 0; cnt < pad; cnt++) {
3096 if(j->fskdcnt < (j->fsksize - 1))
3097 j->fskdata[j->fskdcnt++] = 0x0000;
3098 }
3099 for (cnt = 0; cnt < 720; cnt++) {
3100 if(j->fskdcnt < (j->fsksize - 1))
3101 j->fskdata[j->fskdcnt++] = 0x0000;
3102 }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107 j->cid_play_codec = j->play_codec;
3108 j->cid_play_frame_size = j->play_frame_size;
3109 j->cid_play_volume = get_play_volume(j);
3110 j->cid_play_flag = j->flags.playing;
3111
3112 j->cid_rec_codec = j->rec_codec;
3113 j->cid_rec_volume = get_rec_volume(j);
3114 j->cid_rec_flag = j->flags.recording;
3115
3116 j->cid_play_aec_level = j->aec_level;
3117
3118 switch(j->baseframe.low) {
3119 case 0xA0:
3120 j->cid_base_frame_size = 20;
3121 break;
3122 case 0x50:
3123 j->cid_base_frame_size = 10;
3124 break;
3125 case 0xF0:
3126 j->cid_base_frame_size = 30;
3127 break;
3128 }
3129
3130 ixj_play_stop(j);
3131 ixj_cpt_stop(j);
3132
3133 j->flags.cidplay = 1;
3134
3135 set_base_frame(j, 30);
3136 set_play_codec(j, LINEAR16);
3137 set_play_volume(j, 0x1B);
3138 ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143 ixj_play_stop(j);
3144
3145 if(j->cidsize > 5000) {
3146 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147 }
3148 j->flags.cidplay = 0;
3149 if(ixjdebug & 0x0200) {
3150 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151 }
3152
3153 ixj_fsk_free(j);
3154
3155 j->fskdcnt = 0;
3156 set_base_frame(j, j->cid_base_frame_size);
3157 set_play_codec(j, j->cid_play_codec);
3158 ixj_aec_start(j, j->cid_play_aec_level);
3159 set_play_volume(j, j->cid_play_volume);
3160
3161 set_rec_codec(j, j->cid_rec_codec);
3162 set_rec_volume(j, j->cid_rec_volume);
3163
3164 if(j->cid_rec_flag)
3165 ixj_record_start(j);
3166
3167 if(j->cid_play_flag)
3168 ixj_play_start(j);
3169
3170 if(j->cid_play_flag) {
3171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3172 }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177 char sdmf1[50];
3178 char sdmf2[50];
3179 char sdmf3[80];
3180 char mdmflen, len1, len2, len3;
3181 int pad;
3182
3183 int checksum = 0;
3184
3185 if (j->dsp.low == 0x20 || j->flags.cidplay)
3186 return;
3187
3188 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189 j->cidsize = j->cidcnt = 0;
3190
3191 ixj_fsk_alloc(j);
3192
3193 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 threshold at 3dB */
4194
4195 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197 /* Now we can set the AGC initial parameters and turn it on */
4198 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minimum gain */
4199 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220 ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222 break;
4223
4224 case AEC_AUTO:
4225 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227 ixj_WriteDSPCommand(0xE011, j);
4228 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233 ixj_WriteDSPCommand(0x0224, j);
4234 else
4235 ixj_WriteDSPCommand(0x1224, j);
4236
4237 ixj_WriteDSPCommand(0xE014, j);
4238 ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4239
4240 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242 break;
4243 }
4244 }
4245 }
4246
4247 static void aec_stop(IXJ *j)
4248 {
4249 j->aec_level = AEC_OFF;
4250 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253 ixj_WriteDSPCommand(0x0700, j);
4254 }
4255 if (j->play_mode != -1 && j->rec_mode != -1)
4256 {
4257 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258 }
4259 }
4260
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263 int retval = 0;
4264
4265 j->play_codec = rate;
4266
4267 switch (rate) {
4268 case G723_63:
4269 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270 j->play_frame_size = 12;
4271 j->play_mode = 0;
4272 } else {
4273 retval = 1;
4274 }
4275 break;
4276 case G723_53:
4277 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278 j->play_frame_size = 10;
4279 j->play_mode = 0;
4280 } else {
4281 retval = 1;
4282 }
4283 break;
4284 case TS85:
4285 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286 j->play_frame_size = 16;
4287 j->play_mode = 0;
4288 } else {
4289 retval = 1;
4290 }
4291 break;
4292 case TS48:
4293 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294 j->play_frame_size = 9;
4295 j->play_mode = 0;
4296 } else {
4297 retval = 1;
4298 }
4299 break;
4300 case TS41:
4301 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302 j->play_frame_size = 8;
4303 j->play_mode = 0;
4304 } else {
4305 retval = 1;
4306 }
4307 break;
4308 case G728:
4309 if (j->dsp.low != 0x20) {
4310 j->play_frame_size = 48;
4311 j->play_mode = 0;
4312 } else {
4313 retval = 1;
4314 }
4315 break;
4316 case G729:
4317 if (j->dsp.low != 0x20) {
4318 if (!j->flags.g729_loaded) {
4319 retval = 1;
4320 break;
4321 }
4322 switch (j->baseframe.low) {
4323 case 0xA0:
4324 j->play_frame_size = 10;
4325 break;
4326 case 0x50:
4327 j->play_frame_size = 5;
4328 break;
4329 default:
4330 j->play_frame_size = 15;
4331 break;
4332 }
4333 j->play_mode = 0;
4334 } else {
4335 retval = 1;
4336 }
4337 break;
4338 case G729B:
4339 if (j->dsp.low != 0x20) {
4340 if (!j->flags.g729_loaded) {
4341 retval = 1;
4342 break;
4343 }
4344 switch (j->baseframe.low) {
4345 case 0xA0:
4346 j->play_frame_size = 12;
4347 break;
4348 case 0x50:
4349 j->play_frame_size = 6;
4350 break;
4351 default:
4352 j->play_frame_size = 18;
4353 break;
4354 }
4355 j->play_mode = 0;
4356 } else {
4357 retval = 1;
4358 }
4359 break;
4360 case ULAW:
4361 switch (j->baseframe.low) {
4362 case 0xA0:
4363 j->play_frame_size = 80;
4364 break;
4365 case 0x50:
4366 j->play_frame_size = 40;
4367 break;
4368 default:
4369 j->play_frame_size = 120;
4370 break;
4371 }
4372 j->play_mode = 2;
4373 break;
4374 case ALAW:
4375 switch (j->baseframe.low) {
4376 case 0xA0:
4377 j->play_frame_size = 80;
4378 break;
4379 case 0x50:
4380 j->play_frame_size = 40;
4381 break;
4382 default:
4383 j->play_frame_size = 120;
4384 break;
4385 }
4386 j->play_mode = 2;
4387 break;
4388 case LINEAR16:
4389 switch (j->baseframe.low) {
4390 case 0xA0:
4391 j->play_frame_size = 160;
4392 break;
4393 case 0x50:
4394 j->play_frame_size = 80;
4395 break;
4396 default:
4397 j->play_frame_size = 240;
4398 break;
4399 }
4400 j->play_mode = 6;
4401 break;
4402 case LINEAR8:
4403 switch (j->baseframe.low) {
4404 case 0xA0:
4405 j->play_frame_size = 80;
4406 break;
4407 case 0x50:
4408 j->play_frame_size = 40;
4409 break;
4410 default:
4411 j->play_frame_size = 120;
4412 break;
4413 }
4414 j->play_mode = 4;
4415 break;
4416 case WSS:
4417 switch (j->baseframe.low) {
4418 case 0xA0:
4419 j->play_frame_size = 80;
4420 break;
4421 case 0x50:
4422 j->play_frame_size = 40;
4423 break;
4424 default:
4425 j->play_frame_size = 120;
4426 break;
4427 }
4428 j->play_mode = 5;
4429 break;
4430 default:
4431 kfree(j->write_buffer);
4432 j->play_frame_size = 0;
4433 j->play_mode = -1;
4434 j->write_buffer = NULL;
4435 j->write_buffer_size = 0;
4436 retval = 1;
4437 break;
4438 }
4439 return retval;
4440 }
4441
4442 static int ixj_play_start(IXJ *j)
4443 {
4444 unsigned short cmd = 0x0000;
4445
4446 if (j->write_buffer) {
4447 ixj_play_stop(j);
4448 }
4449
4450 if(ixjdebug & 0x0002)
4451 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453 j->flags.playing = 1;
4454 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456 j->flags.play_first_frame = 1;
4457 j->drybuffer = 0;
4458
4459 if (!j->play_mode) {
4460 switch (j->play_codec) {
4461 case G723_63:
4462 cmd = 0x5231;
4463 break;
4464 case G723_53:
4465 cmd = 0x5232;
4466 break;
4467 case TS85:
4468 cmd = 0x5230; /* TrueSpeech 8.5 */
4469
4470 break;
4471 case TS48:
4472 cmd = 0x5233; /* TrueSpeech 4.8 */
4473
4474 break;
4475 case TS41:
4476 cmd = 0x5234; /* TrueSpeech 4.1 */
4477
4478 break;
4479 case G728:
4480 cmd = 0x5235;
4481 break;
4482 case G729:
4483 case G729B:
4484 cmd = 0x5236;
4485 break;
4486 default:
4487 return 1;
4488 }
4489 if (ixj_WriteDSPCommand(cmd, j))
4490 return -1;
4491 }
4492 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493 if (!j->write_buffer) {
4494 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495 return -ENOMEM;
4496 }
4497 /* j->write_buffers_empty = 2; */
4498 j->write_buffers_empty = 1;
4499 j->write_buffer_size = j->play_frame_size * 2;
4500 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4504
4505 return -1;
4506
4507 switch (j->play_mode) {
4508 case 0:
4509 cmd = 0x2C03;
4510 break;
4511 case 2:
4512 if (j->ver.low == 0x12) {
4513 cmd = 0x2C23;
4514 } else {
4515 cmd = 0x2C21;
4516 }
4517 break;
4518 case 4:
4519 if (j->ver.low == 0x12) {
4520 cmd = 0x2C43;
4521 } else {
4522 cmd = 0x2C41;
4523 }
4524 break;
4525 case 5:
4526 if (j->ver.low == 0x12) {
4527 cmd = 0x2C53;
4528 } else {
4529 cmd = 0x2C51;
4530 }
4531 break;
4532 case 6:
4533 if (j->ver.low == 0x12) {
4534 cmd = 0x2C63;
4535 } else {
4536 cmd = 0x2C61;
4537 }
4538 break;
4539 }
4540 if (ixj_WriteDSPCommand(cmd, j))
4541 return -1;
4542
4543 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4544 return -1;
4545
4546 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4547 return -1;
4548
4549 if (j->flags.recording) {
4550 ixj_aec_start(j, j->aec_level);
4551 }
4552
4553 return 0;
4554 }
4555
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558 if (ixjdebug & 0x0002)
4559 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561 kfree(j->write_buffer);
4562 j->write_buffer = NULL;
4563 j->write_buffer_size = 0;
4564 if (j->play_mode > -1) {
4565 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4566
4567 j->play_mode = -1;
4568 }
4569 j->flags.playing = 0;
4570 }
4571
4572 static inline int get_play_level(IXJ *j)
4573 {
4574 int retval;
4575
4576 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577 return j->ssr.high << 8 | j->ssr.low;
4578 retval = j->ssr.high << 8 | j->ssr.low;
4579 retval = (retval * 256) / 240;
4580 return retval;
4581 }
4582
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585 unsigned int mask = 0;
4586
4587 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588
4589 poll_wait(file_p, &(j->poll_q), wait);
4590 if (j->read_buffer_ready > 0)
4591 mask |= POLLIN | POLLRDNORM; /* readable */
4592 if (j->write_buffers_empty > 0)
4593 mask |= POLLOUT | POLLWRNORM; /* writable */
4594 if (j->ex.bytes)
4595 mask |= POLLPRI;
4596 return mask;
4597 }
4598
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601 if (!j->tone_state) {
4602 if(ixjdebug & 0x0002) {
4603 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604 }
4605 if (j->dsp.low == 0x20) {
4606 idle(j);
4607 }
4608 j->tone_start_jif = jiffies;
4609
4610 j->tone_state = 1;
4611 }
4612
4613 j->tone_index = tone;
4614 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615 return -1;
4616
4617 return 0;
4618 }
4619
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622 j->tone_on_time = arg;
4623
4624 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4625
4626 return -1;
4627
4628 if (ixj_WriteDSPCommand(arg, j))
4629 return -1;
4630
4631 return 0;
4632 }
4633
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636 int cnt;
4637
4638 j->pld_scrr.byte = inb_p(j->XILINXbase);
4639 if (!j->pld_scrr.bits.sci) {
4640 for (cnt = 0; cnt < 10; cnt++) {
4641 udelay(32);
4642 j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644 if ((j->pld_scrr.bits.sci))
4645 return 1;
4646 }
4647 if (ixjdebug & 0x0001)
4648 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649 return 0;
4650 } else
4651 return 1;
4652 }
4653
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656 int cnt;
4657
4658 j->pld_scrr.byte = inb_p(j->XILINXbase);
4659 if (j->pld_scrr.bits.sci) {
4660 for (cnt = 0; cnt < 10; cnt++) {
4661 udelay(32);
4662 j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664 if (!(j->pld_scrr.bits.sci))
4665 return 1;
4666 }
4667 if (ixjdebug & 0x0001)
4668 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669 return 0;
4670 } else
4671 return 1;
4672 }
4673
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676 switch (control) {
4677 case SCI_End:
4678 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4679
4680 j->pld_scrw.bits.c1 = 0; /* to no selection */
4681
4682 break;
4683 case SCI_Enable_DAA:
4684 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4685
4686 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4687
4688 break;
4689 case SCI_Enable_Mixer:
4690 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4691
4692 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4693
4694 break;
4695 case SCI_Enable_EEPROM:
4696 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4697
4698 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4699
4700 break;
4701 default:
4702 return 0;
4703 break;
4704 }
4705 outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707 switch (control) {
4708 case SCI_End:
4709 return 1;
4710 break;
4711 case SCI_Enable_DAA:
4712 case SCI_Enable_Mixer:
4713 case SCI_Enable_EEPROM:
4714 if (!SCI_WaitHighSCI(j))
4715 return 0;
4716 break;
4717 default:
4718 return 0;
4719 break;
4720 }
4721 return 1;
4722 }
4723
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726 if (!SCI_Control(j, SCI_End))
4727 return 0;
4728
4729 if (!SCI_WaitLowSCI(j))
4730 return 0;
4731
4732 return 1;
4733 }
4734
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737 int reg = (val & 0x1F00) >> 8;
4738 return j->mix.vol[reg];
4739 }
4740
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743 BYTES bytes;
4744
4745 bytes.high = (val & 0x1F00) >> 8;
4746 bytes.low = val & 0x00FF;
4747
4748 /* save mixer value so we can get back later on */
4749 j->mix.vol[bytes.high] = bytes.low;
4750
4751 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4752
4753 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4754
4755 SCI_Control(j, SCI_Enable_Mixer);
4756
4757 SCI_Control(j, SCI_End);
4758
4759 return 0;
4760 }
4761
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766 if (!SCI_Control(j, SCI_Enable_DAA))
4767 return 0;
4768 else
4769 return 1;
4770 }
4771
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774 BYTES bytes;
4775
4776 switch (j->daa_mode) {
4777 case SOP_PU_SLEEP:
4778 bytes.high = 0x14;
4779 break;
4780 case SOP_PU_RINGING:
4781 bytes.high = 0x54;
4782 break;
4783 case SOP_PU_CONVERSATION:
4784 bytes.high = 0x94;
4785 break;
4786 case SOP_PU_PULSEDIALING:
4787 bytes.high = 0xD4;
4788 break;
4789 }
4790
4791 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794 case 0:
4795 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796 break;
4797 case 1:
4798 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799 break;
4800 case 2:
4801 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802 break;
4803 case 3:
4804 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805 break;
4806 }
4807
4808 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810 if (!daa_load(&bytes, j))
4811 return 0;
4812
4813 if (!SCI_Prepare(j))
4814 return 0;
4815
4816 return 1;
4817 }
4818
4819 static char daa_int_read(IXJ *j)
4820 {
4821 BYTES bytes;
4822
4823 if (!SCI_Prepare(j))
4824 return 0;
4825
4826 bytes.high = 0x38;
4827 bytes.low = 0x00;
4828 outb_p(bytes.high, j->XILINXbase + 0x03);
4829 outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831 if (!SCI_Control(j, SCI_Enable_DAA))
4832 return 0;
4833
4834 bytes.high = inb_p(j->XILINXbase + 0x03);
4835 bytes.low = inb_p(j->XILINXbase + 0x02);
4836 if (bytes.low != ALISDAA_ID_BYTE) {
4837 if (ixjdebug & 0x0001)
4838 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839 return 0;
4840 }
4841 if (!SCI_Control(j, SCI_Enable_DAA))
4842 return 0;
4843 if (!SCI_Control(j, SCI_End))
4844 return 0;
4845
4846 bytes.high = inb_p(j->XILINXbase + 0x03);
4847 bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851 return 1;
4852 }
4853
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856 IXJ_WORD wdata;
4857 BYTES bytes;
4858
4859 if (!SCI_Prepare(j))
4860 return 0;
4861
4862 switch (j->daa_mode) {
4863 case SOP_PU_SLEEP:
4864 bytes.high = 0x30 + cr;
4865 break;
4866 case SOP_PU_RINGING:
4867 bytes.high = 0x70 + cr;
4868 break;
4869 case SOP_PU_CONVERSATION:
4870 bytes.high = 0xB0 + cr;
4871 break;
4872 case SOP_PU_PULSEDIALING:
4873 default:
4874 bytes.high = 0xF0 + cr;
4875 break;
4876 }
4877
4878 bytes.low = 0x00;
4879
4880 outb_p(bytes.high, j->XILINXbase + 0x03);
4881 outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883 if (!SCI_Control(j, SCI_Enable_DAA))
4884 return 0;
4885
4886 bytes.high = inb_p(j->XILINXbase + 0x03);
4887 bytes.low = inb_p(j->XILINXbase + 0x02);
4888 if (bytes.low != ALISDAA_ID_BYTE) {
4889 if (ixjdebug & 0x0001)
4890 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891 return 0;
4892 }
4893 if (!SCI_Control(j, SCI_Enable_DAA))
4894 return 0;
4895 if (!SCI_Control(j, SCI_End))
4896 return 0;
4897
4898 wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900 switch(cr){
4901 case 5:
4902 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903 break;
4904 case 4:
4905 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906 break;
4907 case 3:
4908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909 break;
4910 case 2:
4911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912 break;
4913 case 1:
4914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915 break;
4916 case 0:
4917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918 break;
4919 default:
4920 return 0;
4921 }
4922 return 1;
4923 }
4924
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927 int i;
4928 BYTES bytes;
4929
4930 if (ixjdebug & 0x0002)
4931 printk("DAA Clearing CID ram\n");
4932
4933 if (!SCI_Prepare(j))
4934 return 0;
4935
4936 bytes.high = 0x58;
4937 bytes.low = 0x00;
4938 outb_p(bytes.high, j->XILINXbase + 0x03);
4939 outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941 if (!SCI_Control(j, SCI_Enable_DAA))
4942 return 0;
4943
4944 if (!SCI_WaitHighSCI(j))
4945 return 0;
4946
4947 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948 bytes.high = bytes.low = 0x00;
4949 outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951 if (i < ALISDAA_CALLERID_SIZE - 1)
4952 outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954 if (!SCI_Control(j, SCI_Enable_DAA))
4955 return 0;
4956
4957 if (!SCI_WaitHighSCI(j))
4958 return 0;
4959
4960 }
4961
4962 if (!SCI_Control(j, SCI_End))
4963 return 0;
4964
4965 if (ixjdebug & 0x0002)
4966 printk("DAA CID ram cleared\n");
4967
4968 return 1;
4969 }
4970
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973 int i;
4974 BYTES bytes;
4975 char CID[ALISDAA_CALLERID_SIZE];
4976 bool mContinue;
4977 char *pIn, *pOut;
4978
4979 if (!SCI_Prepare(j))
4980 return 0;
4981
4982 bytes.high = 0x78;
4983 bytes.low = 0x00;
4984 outb_p(bytes.high, j->XILINXbase + 0x03);
4985 outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987 if (!SCI_Control(j, SCI_Enable_DAA))
4988 return 0;
4989
4990 if (!SCI_WaitHighSCI(j))
4991 return 0;
4992
4993 bytes.high = inb_p(j->XILINXbase + 0x03);
4994 bytes.low = inb_p(j->XILINXbase + 0x02);
4995 if (bytes.low != ALISDAA_ID_BYTE) {
4996 if (ixjdebug & 0x0001)
4997 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998 return 0;
4999 }
5000 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001 bytes.high = bytes.low = 0x00;
5002 outb_p(bytes.high, j->XILINXbase + 0x03);
5003 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005 if (!SCI_Control(j, SCI_Enable_DAA))
5006 return 0;
5007
5008 if (!SCI_WaitHighSCI(j))
5009 return 0;
5010
5011 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013 }
5014
5015 if (!SCI_Control(j, SCI_End))
5016 return 0;
5017
5018 pIn = CID;
5019 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020 mContinue = true;
5021 while (mContinue) {
5022 if ((pIn[1] & 0x03) == 0x01) {
5023 pOut[0] = pIn[0];
5024 }
5025 if ((pIn[2] & 0x0c) == 0x04) {
5026 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027 }
5028 if ((pIn[3] & 0x30) == 0x10) {
5029 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030 }
5031 if ((pIn[4] & 0xc0) == 0x40) {
5032 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033 } else {
5034 mContinue = false;
5035 }
5036 pIn += 5, pOut += 4;
5037 }
5038 memset(&j->cid, 0, sizeof(PHONE_CID));
5039 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040 pOut += 4;
5041 strncpy(j->cid.month, pOut, 2);
5042 pOut += 2;
5043 strncpy(j->cid.day, pOut, 2);
5044 pOut += 2;
5045 strncpy(j->cid.hour, pOut, 2);
5046 pOut += 2;
5047 strncpy(j->cid.min, pOut, 2);
5048 pOut += 3;
5049 j->cid.numlen = *pOut;
5050 pOut += 1;
5051 strncpy(j->cid.number, pOut, j->cid.numlen);
5052 pOut += j->cid.numlen + 1;
5053 j->cid.namelen = *pOut;
5054 pOut += 1;
5055 strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057 ixj_daa_cid_reset(j);
5058 return 1;
5059 }
5060
5061 static char daa_get_version(IXJ *j)
5062 {
5063 BYTES bytes;
5064
5065 if (!SCI_Prepare(j))
5066 return 0;
5067
5068 bytes.high = 0x35;
5069 bytes.low = 0x00;
5070 outb_p(bytes.high, j->XILINXbase + 0x03);
5071 outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073 if (!SCI_Control(j, SCI_Enable_DAA))
5074 return 0;
5075
5076 bytes.high = inb_p(j->XILINXbase + 0x03);
5077 bytes.low = inb_p(j->XILINXbase + 0x02);
5078 if (bytes.low != ALISDAA_ID_BYTE) {
5079 if (ixjdebug & 0x0001)
5080 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081 return 0;
5082 }
5083 if (!SCI_Control(j, SCI_Enable_DAA))
5084 return 0;
5085
5086 if (!SCI_Control(j, SCI_End))
5087 return 0;
5088
5089 bytes.high = inb_p(j->XILINXbase + 0x03);
5090 bytes.low = inb_p(j->XILINXbase + 0x02);
5091 if (ixjdebug & 0x0002)
5092 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094 return bytes.high;
5095 }
5096
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099 /* NOTE:
5100 The DAA *MUST* be in the conversation mode if the
5101 PSTN line is to be seized (PSTN line off-hook).
5102 Taking the PSTN line off-hook while the DAA is in
5103 a mode other than conversation mode will cause a
5104 hardware failure of the ALIS-A part.
5105
5106 NOTE:
5107 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108 if the PSTN line is on-hook. Failure to have the PSTN line
5109 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110 ALIS-A part.
5111 */
5112
5113 BYTES bytes;
5114
5115 j->flags.pstn_rmr = 0;
5116
5117 if (!SCI_Prepare(j))
5118 return 0;
5119
5120 switch (mode) {
5121 case SOP_PU_RESET:
5122 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5123
5124 outb_p(j->pld_scrw.byte, j->XILINXbase);
5125 j->pld_slicw.bits.rly2 = 0;
5126 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127 bytes.high = 0x10;
5128 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129 daa_load(&bytes, j);
5130 if (!SCI_Prepare(j))
5131 return 0;
5132
5133 j->daa_mode = SOP_PU_SLEEP;
5134 break;
5135 case SOP_PU_SLEEP:
5136 if(j->daa_mode == SOP_PU_SLEEP)
5137 {
5138 break;
5139 }
5140 if (ixjdebug & 0x0008)
5141 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5143 {
5144 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5145
5146 outb_p(j->pld_scrw.byte, j->XILINXbase);
5147 j->pld_slicw.bits.rly2 = 0;
5148 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149 bytes.high = 0x10;
5150 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151 daa_load(&bytes, j);
5152 if (!SCI_Prepare(j))
5153 return 0;
5154 }
5155 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5156
5157 outb_p(j->pld_scrw.byte, j->XILINXbase);
5158 j->pld_slicw.bits.rly2 = 0;
5159 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160 bytes.high = 0x10;
5161 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162 daa_load(&bytes, j);
5163 if (!SCI_Prepare(j))
5164 return 0;
5165
5166 j->daa_mode = SOP_PU_SLEEP;
5167 j->flags.pstn_ringing = 0;
5168 j->ex.bits.pstn_ring = 0;
5169 j->pstn_sleeptil = jiffies + (hertz / 4);
5170 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5172 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5173 break;
5174 case SOP_PU_RINGING:
5175 if (ixjdebug & 0x0008)
5176 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5178
5179 outb_p(j->pld_scrw.byte, j->XILINXbase);
5180 j->pld_slicw.bits.rly2 = 0;
5181 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182 bytes.high = 0x50;
5183 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184 daa_load(&bytes, j);
5185 if (!SCI_Prepare(j))
5186 return 0;
5187 j->daa_mode = SOP_PU_RINGING;
5188 break;
5189 case SOP_PU_CONVERSATION:
5190 if (ixjdebug & 0x0008)
5191 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192 bytes.high = 0x90;
5193 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194 daa_load(&bytes, j);
5195 if (!SCI_Prepare(j))
5196 return 0;
5197 j->pld_slicw.bits.rly2 = 1;
5198 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5200
5201 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202 j->daa_mode = SOP_PU_CONVERSATION;
5203 j->flags.pstn_ringing = 0;
5204 j->ex.bits.pstn_ring = 0;
5205 j->pstn_sleeptil = jiffies;
5206 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207 break;
5208 case SOP_PU_PULSEDIALING:
5209 if (ixjdebug & 0x0008)
5210 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5212
5213 outb_p(j->pld_scrw.byte, j->XILINXbase);
5214 j->pld_slicw.bits.rly2 = 0;
5215 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216 bytes.high = 0xD0;
5217 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218 daa_load(&bytes, j);
5219 if (!SCI_Prepare(j))
5220 return 0;
5221 j->daa_mode = SOP_PU_PULSEDIALING;
5222 break;
5223 default:
5224 break;
5225 }
5226 return 1;
5227 }
5228
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231 BYTES bytes;
5232
5233 j->flags.pstncheck = 1;
5234
5235 daa_set_mode(j, SOP_PU_SLEEP);
5236
5237 if (!SCI_Prepare(j))
5238 return 0;
5239
5240 outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242 bytes.high = 0x14;
5243 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244 if (!daa_load(&bytes, j))
5245 return 0;
5246
5247 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249 if (!daa_load(&bytes, j))
5250 return 0;
5251
5252 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254 if (!daa_load(&bytes, j))
5255 return 0;
5256
5257 if (!SCI_Prepare(j))
5258 return 0;
5259
5260 bytes.high = 0x1F;
5261 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262 if (!daa_load(&bytes, j))
5263 return 0;
5264
5265 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267 if (!daa_load(&bytes, j))
5268 return 0;
5269
5270 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272 if (!daa_load(&bytes, j))
5273 return 0;
5274
5275 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277 if (!daa_load(&bytes, j))
5278 return 0;
5279
5280 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281 bytes.low = 0x00;
5282 if (!daa_load(&bytes, j))
5283 return 0;
5284
5285 if (!SCI_Prepare(j))
5286 return 0;
5287
5288 bytes.high = 0x00;
5289 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290 if (!daa_load(&bytes, j))
5291 return 0;
5292
5293 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295 if (!daa_load(&bytes, j))
5296 return 0;
5297
5298 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300 if (!daa_load(&bytes, j))
5301 return 0;
5302
5303 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305 if (!daa_load(&bytes, j))
5306 return 0;
5307
5308 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309 bytes.low = 0x00;
5310 if (!daa_load(&bytes, j))
5311 return 0;
5312
5313 if (!SCI_Control(j, SCI_End))
5314 return 0;
5315 if (!SCI_WaitLowSCI(j))
5316 return 0;
5317
5318 bytes.high = 0x01;
5319 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320 if (!daa_load(&bytes, j))
5321 return 0;
5322
5323 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325 if (!daa_load(&bytes, j))
5326 return 0;
5327
5328 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330 if (!daa_load(&bytes, j))
5331 return 0;
5332
5333 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335 if (!daa_load(&bytes, j))
5336 return 0;
5337
5338 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339 bytes.low = 0x00;
5340 if (!daa_load(&bytes, j))
5341 return 0;
5342
5343 if (!SCI_Control(j, SCI_End))
5344 return 0;
5345 if (!SCI_WaitLowSCI(j))
5346 return 0;
5347
5348 bytes.high = 0x02;
5349 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350 if (!daa_load(&bytes, j))
5351 return 0;
5352
5353 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355 if (!daa_load(&bytes, j))
5356 return 0;
5357
5358 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360 if (!daa_load(&bytes, j))
5361 return 0;
5362
5363 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365 if (!daa_load(&bytes, j))
5366 return 0;
5367
5368 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369 bytes.low = 0x00;
5370 if (!daa_load(&bytes, j))
5371 return 0;
5372
5373 if (!SCI_Control(j, SCI_End))
5374 return 0;
5375 if (!SCI_WaitLowSCI(j))
5376 return 0;
5377
5378 bytes.high = 0x03;
5379 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380 if (!daa_load(&bytes, j))
5381 return 0;
5382
5383 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385 if (!daa_load(&bytes, j))
5386 return 0;
5387
5388 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390 if (!daa_load(&bytes, j))
5391 return 0;
5392
5393 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395 if (!daa_load(&bytes, j))
5396 return 0;
5397
5398 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399 bytes.low = 0x00;
5400 if (!daa_load(&bytes, j))
5401 return 0;
5402
5403 if (!SCI_Control(j, SCI_End))
5404 return 0;
5405 if (!SCI_WaitLowSCI(j))
5406 return 0;
5407
5408 bytes.high = 0x04;
5409 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410 if (!daa_load(&bytes, j))
5411 return 0;
5412
5413 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415 if (!daa_load(&bytes, j))
5416 return 0;
5417
5418 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420 if (!daa_load(&bytes, j))
5421 return 0;
5422
5423 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425 if (!daa_load(&bytes, j))
5426 return 0;
5427
5428 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429 bytes.low = 0x00;
5430 if (!daa_load(&bytes, j))
5431 return 0;
5432
5433 if (!SCI_Control(j, SCI_End))
5434 return 0;
5435 if (!SCI_WaitLowSCI(j))
5436 return 0;
5437
5438 bytes.high = 0x05;
5439 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440 if (!daa_load(&bytes, j))
5441 return 0;
5442
5443 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445 if (!daa_load(&bytes, j))
5446 return 0;
5447
5448 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450 if (!daa_load(&bytes, j))
5451 return 0;
5452
5453 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455 if (!daa_load(&bytes, j))
5456 return 0;
5457
5458 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459 bytes.low = 0x00;
5460 if (!daa_load(&bytes, j))
5461 return 0;
5462
5463 if (!SCI_Control(j, SCI_End))
5464 return 0;
5465 if (!SCI_WaitLowSCI(j))
5466 return 0;
5467
5468 bytes.high = 0x06;
5469 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470 if (!daa_load(&bytes, j))
5471 return 0;
5472
5473 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475 if (!daa_load(&bytes, j))
5476 return 0;
5477
5478 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480 if (!daa_load(&bytes, j))
5481 return 0;
5482
5483 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485 if (!daa_load(&bytes, j))
5486 return 0;
5487
5488 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489 bytes.low = 0x00;
5490 if (!daa_load(&bytes, j))
5491 return 0;
5492
5493 if (!SCI_Control(j, SCI_End))
5494 return 0;
5495 if (!SCI_WaitLowSCI(j))
5496 return 0;
5497
5498 bytes.high = 0x07;
5499 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500 if (!daa_load(&bytes, j))
5501 return 0;
5502
5503 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505 if (!daa_load(&bytes, j))
5506 return 0;
5507
5508 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510 if (!daa_load(&bytes, j))
5511 return 0;
5512
5513 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515 if (!daa_load(&bytes, j))
5516 return 0;
5517
5518 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519 bytes.low = 0x00;
5520 if (!daa_load(&bytes, j))
5521 return 0;
5522
5523 if (!SCI_Control(j, SCI_End))
5524 return 0;
5525 if (!SCI_WaitLowSCI(j))
5526 return 0;
5527
5528 bytes.high = 0x08;
5529 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530 if (!daa_load(&bytes, j))
5531 return 0;
5532
5533 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535 if (!daa_load(&bytes, j))
5536 return 0;
5537
5538 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540 if (!daa_load(&bytes, j))
5541 return 0;
5542
5543 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545 if (!daa_load(&bytes, j))
5546 return 0;
5547
5548 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549 bytes.low = 0x00;
5550 if (!daa_load(&bytes, j))
5551 return 0;
5552
5553 if (!SCI_Control(j, SCI_End))
5554 return 0;
5555 if (!SCI_WaitLowSCI(j))
5556 return 0;
5557
5558 bytes.high = 0x09;
5559 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560 if (!daa_load(&bytes, j))
5561 return 0;
5562
5563 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565 if (!daa_load(&bytes, j))
5566 return 0;
5567
5568 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569 bytes.low = 0x00;
5570 if (!daa_load(&bytes, j))
5571 return 0;
5572
5573 if (!SCI_Control(j, SCI_End))
5574 return 0;
5575 if (!SCI_WaitLowSCI(j))
5576 return 0;
5577
5578 bytes.high = 0x0A;
5579 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580 if (!daa_load(&bytes, j))
5581 return 0;
5582
5583 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585 if (!daa_load(&bytes, j))
5586 return 0;
5587
5588 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589 bytes.low = 0x00;
5590 if (!daa_load(&bytes, j))
5591 return 0;
5592
5593 if (!SCI_Control(j, SCI_End))
5594 return 0;
5595 if (!SCI_WaitLowSCI(j))
5596 return 0;
5597
5598 bytes.high = 0x0B;
5599 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600 if (!daa_load(&bytes, j))
5601 return 0;
5602
5603 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605 if (!daa_load(&bytes, j))
5606 return 0;
5607
5608 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609 bytes.low = 0x00;
5610 if (!daa_load(&bytes, j))
5611 return 0;
5612
5613 if (!SCI_Control(j, SCI_End))
5614 return 0;
5615 if (!SCI_WaitLowSCI(j))
5616 return 0;
5617
5618 bytes.high = 0x0C;
5619 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620 if (!daa_load(&bytes, j))
5621 return 0;
5622
5623 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625 if (!daa_load(&bytes, j))
5626 return 0;
5627
5628 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629 bytes.low = 0x00;
5630 if (!daa_load(&bytes, j))
5631 return 0;
5632
5633 if (!SCI_Control(j, SCI_End))
5634 return 0;
5635 if (!SCI_WaitLowSCI(j))
5636 return 0;
5637
5638 bytes.high = 0x0D;
5639 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640 if (!daa_load(&bytes, j))
5641 return 0;
5642
5643 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645 if (!daa_load(&bytes, j))
5646 return 0;
5647
5648 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649 bytes.low = 0x00;
5650 if (!daa_load(&bytes, j))
5651 return 0;
5652
5653 if (!SCI_Control(j, SCI_End))
5654 return 0;
5655 if (!SCI_WaitLowSCI(j))
5656 return 0;
5657
5658 bytes.high = 0x0E;
5659 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660 if (!daa_load(&bytes, j))
5661 return 0;
5662
5663 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665 if (!daa_load(&bytes, j))
5666 return 0;
5667
5668 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670 if (!daa_load(&bytes, j))
5671 return 0;
5672
5673 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675 if (!daa_load(&bytes, j))
5676 return 0;
5677
5678 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679 bytes.low = 0x00;
5680 if (!daa_load(&bytes, j))
5681 return 0;
5682
5683 if (!SCI_Control(j, SCI_End))
5684 return 0;
5685 if (!SCI_WaitLowSCI(j))
5686 return 0;
5687
5688 bytes.high = 0x0F;
5689 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690 if (!daa_load(&bytes, j))
5691 return 0;
5692
5693 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695 if (!daa_load(&bytes, j))
5696 return 0;
5697
5698 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700 if (!daa_load(&bytes, j))
5701 return 0;
5702
5703 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705 if (!daa_load(&bytes, j))
5706 return 0;
5707
5708 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709 bytes.low = 0x00;
5710 if (!daa_load(&bytes, j))
5711 return 0;
5712
5713 udelay(32);
5714 j->pld_scrr.byte = inb_p(j->XILINXbase);
5715 if (!SCI_Control(j, SCI_End))
5716 return 0;
5717
5718 outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720 if (ixjdebug & 0x0002)
5721 printk("DAA Coefficients Loaded\n");
5722
5723 j->flags.pstncheck = 0;
5724 return 1;
5725 }
5726
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729 j->tone_off_time = arg;
5730 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5731
5732 return -1;
5733 if (ixj_WriteDSPCommand(arg, j))
5734 return -1;
5735 return 0;
5736 }
5737
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5741
5742 return -1;
5743 return 0;
5744 }
5745
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5749
5750 return -1;
5751 return 0;
5752 }
5753
5754 static void ixj_busytone(IXJ *j)
5755 {
5756 j->flags.ringback = 0;
5757 j->flags.dialtone = 0;
5758 j->flags.busytone = 1;
5759 ixj_set_tone_on(0x07D0, j);
5760 ixj_set_tone_off(0x07D0, j);
5761 ixj_play_tone(j, 27);
5762 }
5763
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766 j->flags.ringback = 0;
5767 j->flags.dialtone = 1;
5768 j->flags.busytone = 0;
5769 if (j->dsp.low == 0x20) {
5770 return;
5771 } else {
5772 ixj_set_tone_on(0xFFFF, j);
5773 ixj_set_tone_off(0x0000, j);
5774 ixj_play_tone(j, 25);
5775 }
5776 }
5777
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780 if(j->tone_state || j->tone_cadence_state)
5781 {
5782 j->flags.dialtone = 0;
5783 j->flags.busytone = 0;
5784 j->flags.ringback = 0;
5785 ixj_set_tone_on(0x0001, j);
5786 ixj_set_tone_off(0x0000, j);
5787 ixj_play_tone(j, 0);
5788 j->tone_state = j->tone_cadence_state = 0;
5789 if (j->cadence_t) {
5790 kfree(j->cadence_t->ce);
5791 kfree(j->cadence_t);
5792 j->cadence_t = NULL;
5793 }
5794 }
5795 if (j->play_mode == -1 && j->rec_mode == -1)
5796 idle(j);
5797 if (j->play_mode != -1 && j->dsp.low == 0x20)
5798 ixj_play_start(j);
5799 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800 ixj_record_start(j);
5801 }
5802
5803 static void ixj_ringback(IXJ *j)
5804 {
5805 j->flags.busytone = 0;
5806 j->flags.dialtone = 0;
5807 j->flags.ringback = 1;
5808 ixj_set_tone_on(0x0FA0, j);
5809 ixj_set_tone_off(0x2EE0, j);
5810 ixj_play_tone(j, 26);
5811 }
5812
5813 static void ixj_testram(IXJ *j)
5814 {
5815 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820 ixj_cadence *lcp;
5821 IXJ_CADENCE_ELEMENT __user *cep;
5822 IXJ_CADENCE_ELEMENT *lcep;
5823 IXJ_TONE ti;
5824 int err;
5825
5826 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827 if (lcp == NULL)
5828 return -ENOMEM;
5829
5830 err = -EFAULT;
5831 if (copy_from_user(&lcp->elements_used,
5832 &cp->elements_used, sizeof(int)))
5833 goto out;
5834 if (copy_from_user(&lcp->termination,
5835 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836 goto out;
5837 if (get_user(cep, &cp->ce))
5838 goto out;
5839
5840 err = -EINVAL;
5841 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842 goto out;
5843
5844 err = -ENOMEM;
5845 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846 if (!lcep)
5847 goto out;
5848
5849 err = -EFAULT;
5850 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851 goto out1;
5852
5853 if (j->cadence_t) {
5854 kfree(j->cadence_t->ce);
5855 kfree(j->cadence_t);
5856 }
5857 lcp->ce = (void *) lcep;
5858 j->cadence_t = lcp;
5859 j->tone_cadence_state = 0;
5860 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868 ixj_init_tone(j, &ti);
5869 }
5870 ixj_play_tone(j, lcp->ce[0].index);
5871 return 1;
5872 out1:
5873 kfree(lcep);
5874 out:
5875 kfree(lcp);
5876 return err;
5877 }
5878
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881 IXJ_FILTER_CADENCE *lcp;
5882 lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
5883 if (IS_ERR(lcp)) {
5884 if(ixjdebug & 0x0001) {
5885 printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
5886 }
5887 return PTR_ERR(lcp);
5888 }
5889 if (lcp->filter > 5) {
5890 if(ixjdebug & 0x0001) {
5891 printk(KERN_INFO "Cadence out of range\n");
5892 }
5893 kfree(lcp);
5894 return -1;
5895 }
5896 j->cadence_f[lcp->filter].state = 0;
5897 j->cadence_f[lcp->filter].enable = lcp->enable;
5898 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5899 j->cadence_f[lcp->filter].on1 = lcp->on1;
5900 j->cadence_f[lcp->filter].on1min = 0;
5901 j->cadence_f[lcp->filter].on1max = 0;
5902 j->cadence_f[lcp->filter].off1 = lcp->off1;
5903 j->cadence_f[lcp->filter].off1min = 0;
5904 j->cadence_f[lcp->filter].off1max = 0;
5905 j->cadence_f[lcp->filter].on2 = lcp->on2;
5906 j->cadence_f[lcp->filter].on2min = 0;
5907 j->cadence_f[lcp->filter].on2max = 0;
5908 j->cadence_f[lcp->filter].off2 = lcp->off2;
5909 j->cadence_f[lcp->filter].off2min = 0;
5910 j->cadence_f[lcp->filter].off2max = 0;
5911 j->cadence_f[lcp->filter].on3 = lcp->on3;
5912 j->cadence_f[lcp->filter].on3min = 0;
5913 j->cadence_f[lcp->filter].on3max = 0;
5914 j->cadence_f[lcp->filter].off3 = lcp->off3;
5915 j->cadence_f[lcp->filter].off3min = 0;
5916 j->cadence_f[lcp->filter].off3max = 0;
5917 if(ixjdebug & 0x0002) {
5918 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5919 }
5920 kfree(lcp);
5921 return 0;
5922 }
5923
5924 static void add_caps(IXJ *j)
5925 {
5926 j->caps = 0;
5927 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5928 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5929 j->caplist[j->caps].captype = vendor;
5930 j->caplist[j->caps].handle = j->caps++;
5931 j->caplist[j->caps].captype = device;
5932 switch (j->cardtype) {
5933 case QTI_PHONEJACK:
5934 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5935 break;
5936 case QTI_LINEJACK:
5937 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5938 break;
5939 case QTI_PHONEJACK_LITE:
5940 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5941 break;
5942 case QTI_PHONEJACK_PCI:
5943 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5944 break;
5945 case QTI_PHONECARD:
5946 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5947 break;
5948 }
5949 j->caplist[j->caps].cap = j->cardtype;
5950 j->caplist[j->caps].handle = j->caps++;
5951 strcpy(j->caplist[j->caps].desc, "POTS");
5952 j->caplist[j->caps].captype = port;
5953 j->caplist[j->caps].cap = pots;
5954 j->caplist[j->caps].handle = j->caps++;
5955
5956 /* add devices that can do speaker/mic */
5957 switch (j->cardtype) {
5958 case QTI_PHONEJACK:
5959 case QTI_LINEJACK:
5960 case QTI_PHONEJACK_PCI:
5961 case QTI_PHONECARD:
5962 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5963 j->caplist[j->caps].captype = port;
5964 j->caplist[j->caps].cap = speaker;
5965 j->caplist[j->caps].handle = j->caps++;
5966 default:
5967 break;
5968 }
5969
5970 /* add devices that can do handset */
5971 switch (j->cardtype) {
5972 case QTI_PHONEJACK:
5973 strcpy(j->caplist[j->caps].desc, "HANDSET");
5974 j->caplist[j->caps].captype = port;
5975 j->caplist[j->caps].cap = handset;
5976 j->caplist[j->caps].handle = j->caps++;
5977 break;
5978 default:
5979 break;
5980 }
5981
5982 /* add devices that can do PSTN */
5983 switch (j->cardtype) {
5984 case QTI_LINEJACK:
5985 strcpy(j->caplist[j->caps].desc, "PSTN");
5986 j->caplist[j->caps].captype = port;
5987 j->caplist[j->caps].cap = pstn;
5988 j->caplist[j->caps].handle = j->caps++;
5989 break;
5990 default:
5991 break;
5992 }
5993
5994 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5995 strcpy(j->caplist[j->caps].desc, "ULAW");
5996 j->caplist[j->caps].captype = codec;
5997 j->caplist[j->caps].cap = ULAW;
5998 j->caplist[j->caps].handle = j->caps++;
5999
6000 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6001 j->caplist[j->caps].captype = codec;
6002 j->caplist[j->caps].cap = LINEAR16;
6003 j->caplist[j->caps].handle = j->caps++;
6004
6005 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6006 j->caplist[j->caps].captype = codec;
6007 j->caplist[j->caps].cap = LINEAR8;
6008 j->caplist[j->caps].handle = j->caps++;
6009
6010 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6011 j->caplist[j->caps].captype = codec;
6012 j->caplist[j->caps].cap = WSS;
6013 j->caplist[j->caps].handle = j->caps++;
6014
6015 /* software ALAW codec, made from ULAW */
6016 strcpy(j->caplist[j->caps].desc, "ALAW");
6017 j->caplist[j->caps].captype = codec;
6018 j->caplist[j->caps].cap = ALAW;
6019 j->caplist[j->caps].handle = j->caps++;
6020
6021 /* version 12 of the 8020 does the following codecs in a broken way */
6022 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6023 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6024 j->caplist[j->caps].captype = codec;
6025 j->caplist[j->caps].cap = G723_63;
6026 j->caplist[j->caps].handle = j->caps++;
6027
6028 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6029 j->caplist[j->caps].captype = codec;
6030 j->caplist[j->caps].cap = G723_53;
6031 j->caplist[j->caps].handle = j->caps++;
6032
6033 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6034 j->caplist[j->caps].captype = codec;
6035 j->caplist[j->caps].cap = TS48;
6036 j->caplist[j->caps].handle = j->caps++;
6037
6038 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6039 j->caplist[j->caps].captype = codec;
6040 j->caplist[j->caps].cap = TS41;
6041 j->caplist[j->caps].handle = j->caps++;
6042 }
6043
6044 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6045 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6046 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6047 j->caplist[j->caps].captype = codec;
6048 j->caplist[j->caps].cap = TS85;
6049 j->caplist[j->caps].handle = j->caps++;
6050 }
6051
6052 /* 8021 chips can do G728 */
6053 if (j->dsp.low == 0x21) {
6054 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6055 j->caplist[j->caps].captype = codec;
6056 j->caplist[j->caps].cap = G728;
6057 j->caplist[j->caps].handle = j->caps++;
6058 }
6059
6060 /* 8021/8022 chips can do G729 if loaded */
6061 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6062 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6063 j->caplist[j->caps].captype = codec;
6064 j->caplist[j->caps].cap = G729;
6065 j->caplist[j->caps].handle = j->caps++;
6066 }
6067 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6068 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6069 j->caplist[j->caps].captype = codec;
6070 j->caplist[j->caps].cap = G729B;
6071 j->caplist[j->caps].handle = j->caps++;
6072 }
6073 }
6074
6075 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6076 {
6077 int cnt;
6078 int retval = 0;
6079 for (cnt = 0; cnt < j->caps; cnt++) {
6080 if (pcreq->captype == j->caplist[cnt].captype
6081 && pcreq->cap == j->caplist[cnt].cap) {
6082 retval = 1;
6083 break;
6084 }
6085 }
6086 return retval;
6087 }
6088
6089 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6090 {
6091 IXJ_TONE ti;
6092 IXJ_FILTER jf;
6093 IXJ_FILTER_RAW jfr;
6094 void __user *argp = (void __user *)arg;
6095 struct inode *inode = file_p->f_path.dentry->d_inode;
6096 unsigned int minor = iminor(inode);
6097 unsigned int raise, mant;
6098 int board = NUM(inode);
6099
6100 IXJ *j = get_ixj(NUM(inode));
6101
6102 int retval = 0;
6103
6104 /*
6105 * Set up locks to ensure that only one process is talking to the DSP at a time.
6106 * This is necessary to keep the DSP from locking up.
6107 */
6108 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6109 schedule_timeout_interruptible(1);
6110 if (ixjdebug & 0x0040)
6111 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6112 if (minor >= IXJMAX) {
6113 clear_bit(board, &j->busyflags);
6114 return -ENODEV;
6115 }
6116 /*
6117 * Check ioctls only root can use.
6118 */
6119 if (!capable(CAP_SYS_ADMIN)) {
6120 switch (cmd) {
6121 case IXJCTL_TESTRAM:
6122 case IXJCTL_HZ:
6123 retval = -EPERM;
6124 }
6125 }
6126 switch (cmd) {
6127 case IXJCTL_TESTRAM:
6128 ixj_testram(j);
6129 retval = (j->ssr.high << 8) + j->ssr.low;
6130 break;
6131 case IXJCTL_CARDTYPE:
6132 retval = j->cardtype;
6133 break;
6134 case IXJCTL_SERIAL:
6135 retval = j->serial;
6136 break;
6137 case IXJCTL_VERSION:
6138 {
6139 char arg_str[100];
6140 snprintf(arg_str, sizeof(arg_str),
6141 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6142 IXJ_VER_MINOR, IXJ_BLD_VER);
6143 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6144 retval = -EFAULT;
6145 }
6146 break;
6147 case PHONE_RING_CADENCE:
6148 j->ring_cadence = arg;
6149 break;
6150 case IXJCTL_CIDCW:
6151 if(arg) {
6152 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6153 retval = -EFAULT;
6154 break;
6155 }
6156 } else {
6157 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6158 }
6159 ixj_write_cidcw(j);
6160 break;
6161 /* Binary compatbility */
6162 case OLD_PHONE_RING_START:
6163 arg = 0;
6164 /* Fall through */
6165 case PHONE_RING_START:
6166 if(arg) {
6167 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6168 retval = -EFAULT;
6169 break;
6170 }
6171 ixj_write_cid(j);
6172 } else {
6173 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6174 }
6175 ixj_ring_start(j);
6176 break;
6177 case PHONE_RING_STOP:
6178 j->flags.cringing = 0;
6179 if(j->cadence_f[5].enable) {
6180 j->cadence_f[5].state = 0;
6181 }
6182 ixj_ring_off(j);
6183 break;
6184 case PHONE_RING:
6185 retval = ixj_ring(j);
6186 break;
6187 case PHONE_EXCEPTION:
6188 retval = j->ex.bytes;
6189 if(j->ex.bits.flash) {
6190 j->flash_end = 0;
6191 j->ex.bits.flash = 0;
6192 }
6193 j->ex.bits.pstn_ring = 0;
6194 j->ex.bits.caller_id = 0;
6195 j->ex.bits.pstn_wink = 0;
6196 j->ex.bits.f0 = 0;
6197 j->ex.bits.f1 = 0;
6198 j->ex.bits.f2 = 0;
6199 j->ex.bits.f3 = 0;
6200 j->ex.bits.fc0 = 0;
6201 j->ex.bits.fc1 = 0;
6202 j->ex.bits.fc2 = 0;
6203 j->ex.bits.fc3 = 0;
6204 j->ex.bits.reserved = 0;
6205 break;
6206 case PHONE_HOOKSTATE:
6207 j->ex.bits.hookstate = 0;
6208 retval = j->hookstate; //j->r_hook;
6209 break;
6210 case IXJCTL_SET_LED:
6211 LED_SetState(arg, j);
6212 break;
6213 case PHONE_FRAME:
6214 retval = set_base_frame(j, arg);
6215 break;
6216 case PHONE_REC_CODEC:
6217 retval = set_rec_codec(j, arg);
6218 break;
6219 case PHONE_VAD:
6220 ixj_vad(j, arg);
6221 break;
6222 case PHONE_REC_START:
6223 ixj_record_start(j);
6224 break;
6225 case PHONE_REC_STOP:
6226 ixj_record_stop(j);
6227 break;
6228 case PHONE_REC_DEPTH:
6229 set_rec_depth(j, arg);
6230 break;
6231 case PHONE_REC_VOLUME:
6232 if(arg == -1) {
6233 retval = get_rec_volume(j);
6234 }
6235 else {
6236 set_rec_volume(j, arg);
6237 retval = arg;
6238 }
6239 break;
6240 case PHONE_REC_VOLUME_LINEAR:
6241 if(arg == -1) {
6242 retval = get_rec_volume_linear(j);
6243 }
6244 else {
6245 set_rec_volume_linear(j, arg);
6246 retval = arg;
6247 }
6248 break;
6249 case IXJCTL_DTMF_PRESCALE:
6250 if(arg == -1) {
6251 retval = get_dtmf_prescale(j);
6252 }
6253 else {
6254 set_dtmf_prescale(j, arg);
6255 retval = arg;
6256 }
6257 break;
6258 case PHONE_REC_LEVEL:
6259 retval = get_rec_level(j);
6260 break;
6261 case IXJCTL_SC_RXG:
6262 retval = ixj_siadc(j, arg);
6263 break;
6264 case IXJCTL_SC_TXG:
6265 retval = ixj_sidac(j, arg);
6266 break;
6267 case IXJCTL_AEC_START:
6268 ixj_aec_start(j, arg);
6269 break;
6270 case IXJCTL_AEC_STOP:
6271 aec_stop(j);
6272 break;
6273 case IXJCTL_AEC_GET_LEVEL:
6274 retval = j->aec_level;
6275 break;
6276 case PHONE_PLAY_CODEC:
6277 retval = set_play_codec(j, arg);
6278 break;
6279 case PHONE_PLAY_START:
6280 retval = ixj_play_start(j);
6281 break;
6282 case PHONE_PLAY_STOP:
6283 ixj_play_stop(j);
6284 break;
6285 case PHONE_PLAY_DEPTH:
6286 set_play_depth(j, arg);
6287 break;
6288 case PHONE_PLAY_VOLUME:
6289 if(arg == -1) {
6290 retval = get_play_volume(j);
6291 }
6292 else {
6293 set_play_volume(j, arg);
6294 retval = arg;
6295 }
6296 break;
6297 case PHONE_PLAY_VOLUME_LINEAR:
6298 if(arg == -1) {
6299 retval = get_play_volume_linear(j);
6300 }
6301 else {
6302 set_play_volume_linear(j, arg);
6303 retval = arg;
6304 }
6305 break;
6306 case PHONE_PLAY_LEVEL:
6307 retval = get_play_level(j);
6308 break;
6309 case IXJCTL_DSP_TYPE:
6310 retval = (j->dsp.high << 8) + j->dsp.low;
6311 break;
6312 case IXJCTL_DSP_VERSION:
6313 retval = (j->ver.high << 8) + j->ver.low;
6314 break;
6315 case IXJCTL_HZ:
6316 hertz = arg;
6317 break;
6318 case IXJCTL_RATE:
6319 if (arg > hertz)
6320 retval = -1;
6321 else
6322 samplerate = arg;
6323 break;
6324 case IXJCTL_DRYBUFFER_READ:
6325 put_user(j->drybuffer, (unsigned long __user *) argp);
6326 break;
6327 case IXJCTL_DRYBUFFER_CLEAR:
6328 j->drybuffer = 0;
6329 break;
6330 case IXJCTL_FRAMES_READ:
6331 put_user(j->framesread, (unsigned long __user *) argp);
6332 break;
6333 case IXJCTL_FRAMES_WRITTEN:
6334 put_user(j->frameswritten, (unsigned long __user *) argp);
6335 break;
6336 case IXJCTL_READ_WAIT:
6337 put_user(j->read_wait, (unsigned long __user *) argp);
6338 break;
6339 case IXJCTL_WRITE_WAIT:
6340 put_user(j->write_wait, (unsigned long __user *) argp);
6341 break;
6342 case PHONE_MAXRINGS:
6343 j->maxrings = arg;
6344 break;
6345 case PHONE_SET_TONE_ON_TIME:
6346 ixj_set_tone_on(arg, j);
6347 break;
6348 case PHONE_SET_TONE_OFF_TIME:
6349 ixj_set_tone_off(arg, j);
6350 break;
6351 case PHONE_GET_TONE_ON_TIME:
6352 if (ixj_get_tone_on(j)) {
6353 retval = -1;
6354 } else {
6355 retval = (j->ssr.high << 8) + j->ssr.low;
6356 }
6357 break;
6358 case PHONE_GET_TONE_OFF_TIME:
6359 if (ixj_get_tone_off(j)) {
6360 retval = -1;
6361 } else {
6362 retval = (j->ssr.high << 8) + j->ssr.low;
6363 }
6364 break;
6365 case PHONE_PLAY_TONE:
6366 if (!j->tone_state)
6367 retval = ixj_play_tone(j, arg);
6368 else
6369 retval = -1;
6370 break;
6371 case PHONE_GET_TONE_STATE:
6372 retval = j->tone_state;
6373 break;
6374 case PHONE_DTMF_READY:
6375 retval = j->ex.bits.dtmf_ready;
6376 break;
6377 case PHONE_GET_DTMF:
6378 if (ixj_hookstate(j)) {
6379 if (j->dtmf_rp != j->dtmf_wp) {
6380 retval = j->dtmfbuffer[j->dtmf_rp];
6381 j->dtmf_rp++;
6382 if (j->dtmf_rp == 79)
6383 j->dtmf_rp = 0;
6384 if (j->dtmf_rp == j->dtmf_wp) {
6385 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6386 }
6387 }
6388 }
6389 break;
6390 case PHONE_GET_DTMF_ASCII:
6391 if (ixj_hookstate(j)) {
6392 if (j->dtmf_rp != j->dtmf_wp) {
6393 switch (j->dtmfbuffer[j->dtmf_rp]) {
6394 case 10:
6395 retval = 42; /* '*'; */
6396
6397 break;
6398 case 11:
6399 retval = 48; /*'0'; */
6400
6401 break;
6402 case 12:
6403 retval = 35; /*'#'; */
6404
6405 break;
6406 case 28:
6407 retval = 65; /*'A'; */
6408
6409 break;
6410 case 29:
6411 retval = 66; /*'B'; */
6412
6413 break;
6414 case 30:
6415 retval = 67; /*'C'; */
6416
6417 break;
6418 case 31:
6419 retval = 68; /*'D'; */
6420
6421 break;
6422 default:
6423 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6424 break;
6425 }
6426 j->dtmf_rp++;
6427 if (j->dtmf_rp == 79)
6428 j->dtmf_rp = 0;
6429 if(j->dtmf_rp == j->dtmf_wp)
6430 {
6431 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6432 }
6433 }
6434 }
6435 break;
6436 case PHONE_DTMF_OOB:
6437 j->flags.dtmf_oob = arg;
6438 break;
6439 case PHONE_DIALTONE:
6440 ixj_dialtone(j);
6441 break;
6442 case PHONE_BUSY:
6443 ixj_busytone(j);
6444 break;
6445 case PHONE_RINGBACK:
6446 ixj_ringback(j);
6447 break;
6448 case PHONE_WINK:
6449 if(j->cardtype == QTI_PHONEJACK)
6450 retval = -1;
6451 else
6452 retval = ixj_wink(j);
6453 break;
6454 case PHONE_CPT_STOP:
6455 ixj_cpt_stop(j);
6456 break;
6457 case PHONE_QUERY_CODEC:
6458 {
6459 struct phone_codec_data pd;
6460 int val;
6461 int proto_size[] = {
6462 -1,
6463 12, 10, 16, 9, 8, 48, 5,
6464 40, 40, 80, 40, 40, 6
6465 };
6466 if(copy_from_user(&pd, argp, sizeof(pd))) {
6467 retval = -EFAULT;
6468 break;
6469 }
6470 if(pd.type<1 || pd.type>13) {
6471 retval = -EPROTONOSUPPORT;
6472 break;
6473 }
6474 if(pd.type<G729)
6475 val=proto_size[pd.type];
6476 else switch(j->baseframe.low)
6477 {
6478 case 0xA0:val=2*proto_size[pd.type];break;
6479 case 0x50:val=proto_size[pd.type];break;
6480 default:val=proto_size[pd.type]*3;break;
6481 }
6482 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6483 if(copy_to_user(argp, &pd, sizeof(pd)))
6484 retval = -EFAULT;
6485 break;
6486 }
6487 case IXJCTL_DSP_IDLE:
6488 idle(j);
6489 break;
6490 case IXJCTL_MIXER:
6491 if ((arg & 0xff) == 0xff)
6492 retval = ixj_get_mixer(arg, j);
6493 else
6494 ixj_mixer(arg, j);
6495 break;
6496 case IXJCTL_DAA_COEFF_SET:
6497 switch (arg) {
6498 case DAA_US:
6499 DAA_Coeff_US(j);
6500 retval = ixj_daa_write(j);
6501 break;
6502 case DAA_UK:
6503 DAA_Coeff_UK(j);
6504 retval = ixj_daa_write(j);
6505 break;
6506 case DAA_FRANCE:
6507 DAA_Coeff_France(j);
6508 retval = ixj_daa_write(j);
6509 break;
6510 case DAA_GERMANY:
6511 DAA_Coeff_Germany(j);
6512 retval = ixj_daa_write(j);
6513 break;
6514 case DAA_AUSTRALIA:
6515 DAA_Coeff_Australia(j);
6516 retval = ixj_daa_write(j);
6517 break;
6518 case DAA_JAPAN:
6519 DAA_Coeff_Japan(j);
6520 retval = ixj_daa_write(j);
6521 break;
6522 default:
6523 retval = 1;
6524 break;
6525 }
6526 break;
6527 case IXJCTL_DAA_AGAIN:
6528 ixj_daa_cr4(j, arg | 0x02);
6529 break;
6530 case IXJCTL_PSTN_LINETEST:
6531 retval = ixj_linetest(j);
6532 break;
6533 case IXJCTL_VMWI:
6534 ixj_write_vmwi(j, arg);
6535 break;
6536 case IXJCTL_CID:
6537 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6538 retval = -EFAULT;
6539 j->ex.bits.caller_id = 0;
6540 break;
6541 case IXJCTL_WINK_DURATION:
6542 j->winktime = arg;
6543 break;
6544 case IXJCTL_PORT:
6545 if (arg)
6546 retval = ixj_set_port(j, arg);
6547 else
6548 retval = j->port;
6549 break;
6550 case IXJCTL_POTS_PSTN:
6551 retval = ixj_set_pots(j, arg);
6552 break;
6553 case PHONE_CAPABILITIES:
6554 add_caps(j);
6555 retval = j->caps;
6556 break;
6557 case PHONE_CAPABILITIES_LIST:
6558 add_caps(j);
6559 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6560 retval = -EFAULT;
6561 break;
6562 case PHONE_CAPABILITIES_CHECK:
6563 {
6564 struct phone_capability cap;
6565 if (copy_from_user(&cap, argp, sizeof(cap)))
6566 retval = -EFAULT;
6567 else {
6568 add_caps(j);
6569 retval = capabilities_check(j, &cap);
6570 }
6571 }
6572 break;
6573 case PHONE_PSTN_SET_STATE:
6574 daa_set_mode(j, arg);
6575 break;
6576 case PHONE_PSTN_GET_STATE:
6577 retval = j->daa_mode;
6578 j->ex.bits.pstn_ring = 0;
6579 break;
6580 case IXJCTL_SET_FILTER:
6581 if (copy_from_user(&jf, argp, sizeof(jf)))
6582 retval = -EFAULT;
6583 else
6584 retval = ixj_init_filter(j, &jf);
6585 break;
6586 case IXJCTL_SET_FILTER_RAW:
6587 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6588 retval = -EFAULT;
6589 else
6590 retval = ixj_init_filter_raw(j, &jfr);
6591 break;
6592 case IXJCTL_GET_FILTER_HIST:
6593 if(arg<0||arg>3)
6594 retval = -EINVAL;
6595 else
6596 retval = j->filter_hist[arg];
6597 break;
6598 case IXJCTL_INIT_TONE:
6599 if (copy_from_user(&ti, argp, sizeof(ti)))
6600 retval = -EFAULT;
6601 else
6602 retval = ixj_init_tone(j, &ti);
6603 break;
6604 case IXJCTL_TONE_CADENCE:
6605 retval = ixj_build_cadence(j, argp);
6606 break;
6607 case IXJCTL_FILTER_CADENCE:
6608 retval = ixj_build_filter_cadence(j, argp);
6609 break;
6610 case IXJCTL_SIGCTL:
6611 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6612 retval = -EFAULT;
6613 break;
6614 }
6615 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6616 if(j->sigdef.event < 33) {
6617 raise = 1;
6618 for(mant = 0; mant < j->sigdef.event; mant++){
6619 raise *= 2;
6620 }
6621 if(j->sigdef.signal)
6622 j->ex_sig.bytes |= raise;
6623 else
6624 j->ex_sig.bytes &= (raise^0xffff);
6625 }
6626 break;
6627 case IXJCTL_INTERCOM_STOP:
6628 if(arg < 0 || arg >= IXJMAX)
6629 return -EINVAL;
6630 j->intercom = -1;
6631 ixj_record_stop(j);
6632 ixj_play_stop(j);
6633 idle(j);
6634 get_ixj(arg)->intercom = -1;
6635 ixj_record_stop(get_ixj(arg));
6636 ixj_play_stop(get_ixj(arg));
6637 idle(get_ixj(arg));
6638 break;
6639 case IXJCTL_INTERCOM_START:
6640 if(arg < 0 || arg >= IXJMAX)
6641 return -EINVAL;
6642 j->intercom = arg;
6643 ixj_record_start(j);
6644 ixj_play_start(j);
6645 get_ixj(arg)->intercom = board;
6646 ixj_play_start(get_ixj(arg));
6647 ixj_record_start(get_ixj(arg));
6648 break;
6649 }
6650 if (ixjdebug & 0x0040)
6651 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6652 clear_bit(board, &j->busyflags);
6653 return retval;
6654 }
6655
6656 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6657 {
6658 long ret;
6659 mutex_lock(&ixj_mutex);
6660 ret = do_ixj_ioctl(file_p, cmd, arg);
6661 mutex_unlock(&ixj_mutex);
6662 return ret;
6663 }
6664
6665 static int ixj_fasync(int fd, struct file *file_p, int mode)
6666 {
6667 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6668
6669 return fasync_helper(fd, file_p, mode, &j->async_queue);
6670 }
6671
6672 static const struct file_operations ixj_fops =
6673 {
6674 .owner = THIS_MODULE,
6675 .read = ixj_enhanced_read,
6676 .write = ixj_enhanced_write,
6677 .poll = ixj_poll,
6678 .unlocked_ioctl = ixj_ioctl,
6679 .release = ixj_release,
6680 .fasync = ixj_fasync,
6681 .llseek = default_llseek,
6682 };
6683
6684 static int ixj_linetest(IXJ *j)
6685 {
6686 j->flags.pstncheck = 1; /* Testing */
6687 j->flags.pstn_present = 0; /* Assume the line is not there */
6688
6689 daa_int_read(j); /*Clear DAA Interrupt flags */
6690 /* */
6691 /* Hold all relays in the normally de-energized position. */
6692 /* */
6693
6694 j->pld_slicw.bits.rly1 = 0;
6695 j->pld_slicw.bits.rly2 = 0;
6696 j->pld_slicw.bits.rly3 = 0;
6697 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6698 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6699
6700 outb_p(j->pld_scrw.byte, j->XILINXbase);
6701 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6702 if (j->pld_slicr.bits.potspstn) {
6703 j->flags.pots_pstn = 1;
6704 j->flags.pots_correct = 0;
6705 LED_SetState(0x4, j);
6706 } else {
6707 j->flags.pots_pstn = 0;
6708 j->pld_slicw.bits.rly1 = 0;
6709 j->pld_slicw.bits.rly2 = 0;
6710 j->pld_slicw.bits.rly3 = 1;
6711 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6712 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6713
6714 outb_p(j->pld_scrw.byte, j->XILINXbase);
6715 daa_set_mode(j, SOP_PU_CONVERSATION);
6716 msleep(1000);
6717 daa_int_read(j);
6718 daa_set_mode(j, SOP_PU_RESET);
6719 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6720 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6721 LED_SetState(0x4, j);
6722 j->pld_slicw.bits.rly3 = 0;
6723 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6724 } else {
6725 j->flags.pots_correct = 1;
6726 LED_SetState(0x8, j);
6727 j->pld_slicw.bits.rly1 = 1;
6728 j->pld_slicw.bits.rly2 = 0;
6729 j->pld_slicw.bits.rly3 = 0;
6730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731 }
6732 }
6733 j->pld_slicw.bits.rly3 = 0;
6734 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6735 daa_set_mode(j, SOP_PU_CONVERSATION);
6736 msleep(1000);
6737 daa_int_read(j);
6738 daa_set_mode(j, SOP_PU_RESET);
6739 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6740 j->pstn_sleeptil = jiffies + (hertz / 4);
6741 j->flags.pstn_present = 1;
6742 } else {
6743 j->flags.pstn_present = 0;
6744 }
6745 if (j->flags.pstn_present) {
6746 if (j->flags.pots_correct) {
6747 LED_SetState(0xA, j);
6748 } else {
6749 LED_SetState(0x6, j);
6750 }
6751 } else {
6752 if (j->flags.pots_correct) {
6753 LED_SetState(0x9, j);
6754 } else {
6755 LED_SetState(0x5, j);
6756 }
6757 }
6758 j->flags.pstncheck = 0; /* Testing */
6759 return j->flags.pstn_present;
6760 }
6761
6762 static int ixj_selfprobe(IXJ *j)
6763 {
6764 unsigned short cmd;
6765 int cnt;
6766 BYTES bytes;
6767
6768 init_waitqueue_head(&j->poll_q);
6769 init_waitqueue_head(&j->read_q);
6770 init_waitqueue_head(&j->write_q);
6771
6772 while(atomic_read(&j->DSPWrite) > 0)
6773 atomic_dec(&j->DSPWrite);
6774 if (ixjdebug & 0x0002)
6775 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6776 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6777
6778 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6779 return -1;
6780 /* The read values of the SSR should be 0x00 for the IDLE command */
6781 if (j->ssr.low || j->ssr.high)
6782 return -1;
6783 if (ixjdebug & 0x0002)
6784 printk(KERN_INFO "Get Device ID Code\n");
6785 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6786 return -1;
6787 j->dsp.low = j->ssr.low;
6788 j->dsp.high = j->ssr.high;
6789 if (ixjdebug & 0x0002)
6790 printk(KERN_INFO "Get Device Version Code\n");
6791 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6792 return -1;
6793 j->ver.low = j->ssr.low;
6794 j->ver.high = j->ssr.high;
6795 if (!j->cardtype) {
6796 if (j->dsp.low == 0x21) {
6797 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6798 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6799 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6800 bytes.low = inb_p(j->XILINXbase + 0x02);
6801 if (bytes.low == bytes.high) /* Register is read only on */
6802 /* Internet PhoneJack Lite */
6803 {
6804 j->cardtype = QTI_PHONEJACK_LITE;
6805 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6806 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6807 return -1;
6808 }
6809 j->pld_slicw.pcib.e1 = 1;
6810 outb_p(j->pld_slicw.byte, j->XILINXbase);
6811 } else {
6812 j->cardtype = QTI_LINEJACK;
6813
6814 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6815 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6816 return -1;
6817 }
6818 }
6819 } else if (j->dsp.low == 0x22) {
6820 j->cardtype = QTI_PHONEJACK_PCI;
6821 request_region(j->XILINXbase, 4, "ixj control");
6822 j->pld_slicw.pcib.e1 = 1;
6823 outb_p(j->pld_slicw.byte, j->XILINXbase);
6824 } else
6825 j->cardtype = QTI_PHONEJACK;
6826 } else {
6827 switch (j->cardtype) {
6828 case QTI_PHONEJACK:
6829 if (!j->dsp.low != 0x20) {
6830 j->dsp.high = 0x80;
6831 j->dsp.low = 0x20;
6832 ixj_WriteDSPCommand(0x3800, j);
6833 j->ver.low = j->ssr.low;
6834 j->ver.high = j->ssr.high;
6835 }
6836 break;
6837 case QTI_LINEJACK:
6838 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6839 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6840 return -1;
6841 }
6842 break;
6843 case QTI_PHONEJACK_LITE:
6844 case QTI_PHONEJACK_PCI:
6845 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6846 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6847 return -1;
6848 }
6849 j->pld_slicw.pcib.e1 = 1;
6850 outb_p(j->pld_slicw.byte, j->XILINXbase);
6851 break;
6852 case QTI_PHONECARD:
6853 break;
6854 }
6855 }
6856 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6857 if (ixjdebug & 0x0002)
6858 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6859 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6860 return -1;
6861 if (ixjdebug & 0x0002)
6862 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6863 if (j->cardtype == QTI_PHONEJACK) {
6864 cmd = 0x9FF2;
6865 } else {
6866 cmd = 0x9FF5;
6867 }
6868 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6869 return -1;
6870 } else {
6871 if (set_base_frame(j, 30) != 30)
6872 return -1;
6873 if (ixjdebug & 0x0002)
6874 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6875 if (j->cardtype == QTI_PHONECARD) {
6876 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6877 return -1;
6878 }
6879 if (j->cardtype == QTI_LINEJACK) {
6880 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6881 return -1;
6882 if (ixjdebug & 0x0002)
6883 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6884 j->pld_clock.byte = 0;
6885 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6886 }
6887 }
6888
6889 if (j->dsp.low == 0x20) {
6890 if (ixjdebug & 0x0002)
6891 printk(KERN_INFO "Configure GPIO pins\n");
6892 j->gpio.bytes.high = 0x09;
6893 /* bytes.low = 0xEF; 0xF7 */
6894 j->gpio.bits.gpio1 = 1;
6895 j->gpio.bits.gpio2 = 1;
6896 j->gpio.bits.gpio3 = 0;
6897 j->gpio.bits.gpio4 = 1;
6898 j->gpio.bits.gpio5 = 1;
6899 j->gpio.bits.gpio6 = 1;
6900 j->gpio.bits.gpio7 = 1;
6901 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6902 if (ixjdebug & 0x0002)
6903 printk(KERN_INFO "Enable SLIC\n");
6904 j->gpio.bytes.high = 0x0B;
6905 j->gpio.bytes.low = 0x00;
6906 j->gpio.bits.gpio1 = 0;
6907 j->gpio.bits.gpio2 = 1;
6908 j->gpio.bits.gpio5 = 0;
6909 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6910 j->port = PORT_POTS;
6911 } else {
6912 if (j->cardtype == QTI_LINEJACK) {
6913 LED_SetState(0x1, j);
6914 msleep(100);
6915 LED_SetState(0x2, j);
6916 msleep(100);
6917 LED_SetState(0x4, j);
6918 msleep(100);
6919 LED_SetState(0x8, j);
6920 msleep(100);
6921 LED_SetState(0x0, j);
6922 daa_get_version(j);
6923 if (ixjdebug & 0x0002)
6924 printk("Loading DAA Coefficients\n");
6925 DAA_Coeff_US(j);
6926 if (!ixj_daa_write(j)) {
6927 printk("DAA write failed on board %d\n", j->board);
6928 return -1;
6929 }
6930 if(!ixj_daa_cid_reset(j)) {
6931 printk("DAA CID reset failed on board %d\n", j->board);
6932 return -1;
6933 }
6934 j->flags.pots_correct = 0;
6935 j->flags.pstn_present = 0;
6936 ixj_linetest(j);
6937 if (j->flags.pots_correct) {
6938 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6939
6940 outb_p(j->pld_scrw.byte, j->XILINXbase);
6941 j->pld_slicw.bits.rly1 = 1;
6942 j->pld_slicw.bits.spken = 1;
6943 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6944 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6945 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6946 j->port = PORT_POTS;
6947 }
6948 ixj_set_port(j, PORT_PSTN);
6949 ixj_set_pots(j, 1);
6950 if (ixjdebug & 0x0002)
6951 printk(KERN_INFO "Enable Mixer\n");
6952 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6953 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6954
6955 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6956 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6957
6958 ixj_mixer(0x0480, j); /*FM Left mute */
6959 ixj_mixer(0x0580, j); /*FM Right mute */
6960
6961 ixj_mixer(0x0680, j); /*CD Left mute */
6962 ixj_mixer(0x0780, j); /*CD Right mute */
6963
6964 ixj_mixer(0x0880, j); /*Line Left mute */
6965 ixj_mixer(0x0980, j); /*Line Right mute */
6966
6967 ixj_mixer(0x0A80, j); /*Aux left mute */
6968 ixj_mixer(0x0B80, j); /*Aux right mute */
6969
6970 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6971 ixj_mixer(0x0D80, j); /*Mono2 mute */
6972
6973 ixj_mixer(0x0E80, j); /*Mic mute */
6974
6975 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6976
6977 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6978 ixj_mixer(0x110C, j);
6979
6980
6981 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6982 ixj_mixer(0x1401, j);
6983
6984 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6985 ixj_mixer(0x1501, j);
6986
6987 ixj_mixer(0x1700, j); /*Clock select */
6988
6989 ixj_mixer(0x1800, j); /*ADC input from mixer */
6990
6991 ixj_mixer(0x1901, j); /*Mic gain 30db */
6992
6993 if (ixjdebug & 0x0002)
6994 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6995 j->cadence_f[4].state = 0;
6996 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6997 j->cadence_f[4].off1 = 0;
6998 j->cadence_f[4].on2 = 0;
6999 j->cadence_f[4].off2 = 0;
7000 j->cadence_f[4].on3 = 0;
7001 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7002 j->pstn_last_rmr = jiffies;
7003
7004 } else {
7005 if (j->cardtype == QTI_PHONECARD) {
7006 ixj_WriteDSPCommand(0xCF07, j);
7007 ixj_WriteDSPCommand(0x00B0, j);
7008 ixj_set_port(j, PORT_SPEAKER);
7009 } else {
7010 ixj_set_port(j, PORT_POTS);
7011 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7012 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7013 }
7014 }
7015 }
7016
7017 j->intercom = -1;
7018 j->framesread = j->frameswritten = 0;
7019 j->read_wait = j->write_wait = 0;
7020 j->rxreadycheck = j->txreadycheck = 0;
7021
7022 /* initialise the DTMF prescale to a sensible value */
7023 if (j->cardtype == QTI_LINEJACK) {
7024 set_dtmf_prescale(j, 0x10);
7025 } else {
7026 set_dtmf_prescale(j, 0x40);
7027 }
7028 set_play_volume(j, 0x100);
7029 set_rec_volume(j, 0x100);
7030
7031 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7032 return -1;
7033 /* The read values of the SSR should be 0x00 for the IDLE command */
7034 if (j->ssr.low || j->ssr.high)
7035 return -1;
7036
7037 if (ixjdebug & 0x0002)
7038 printk(KERN_INFO "Enable Line Monitor\n");
7039
7040 if (ixjdebug & 0x0002)
7041 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7042
7043 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7044 return -1;
7045
7046 if (ixjdebug & 0x002)
7047 printk(KERN_INFO "Enable DTMF Detectors\n");
7048
7049 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7050 return -1;
7051
7052 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7053 return -1;
7054
7055 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7056
7057 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7058
7059 j->ex.bits.dtmf_ready = 0;
7060 j->dtmf_state = 0;
7061 j->dtmf_wp = j->dtmf_rp = 0;
7062 j->rec_mode = j->play_mode = -1;
7063 j->flags.ringing = 0;
7064 j->maxrings = MAXRINGS;
7065 j->ring_cadence = USA_RING_CADENCE;
7066 j->drybuffer = 0;
7067 j->winktime = 320;
7068 j->flags.dtmf_oob = 0;
7069 for (cnt = 0; cnt < 4; cnt++)
7070 j->cadence_f[cnt].enable = 0;
7071 /* must be a device on the specified address */
7072 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7073
7074 /* Set up the default signals for events */
7075 for (cnt = 0; cnt < 35; cnt++)
7076 j->ixj_signals[cnt] = SIGIO;
7077
7078 /* Set the excetion signal enable flags */
7079 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7080 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 =
7081 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;
7082 #ifdef IXJ_DYN_ALLOC
7083 j->fskdata = NULL;
7084 #endif
7085 j->fskdcnt = 0;
7086 j->cidcw_wait = 0;
7087
7088 /* Register with the Telephony for Linux subsystem */
7089 j->p.f_op = &ixj_fops;
7090 j->p.open = ixj_open;
7091 j->p.board = j->board;
7092 phone_register_device(&j->p, PHONE_UNIT_ANY);
7093
7094 ixj_init_timer(j);
7095 ixj_add_timer(j);
7096 return 0;
7097 }
7098
7099 /*
7100 * Exported service for pcmcia card handling
7101 */
7102
7103 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7104 {
7105 IXJ *j = ixj_alloc();
7106
7107 j->board = 0;
7108
7109 j->DSPbase = dsp;
7110 j->XILINXbase = xilinx;
7111 j->cardtype = QTI_PHONECARD;
7112 ixj_selfprobe(j);
7113 return j;
7114 }
7115
7116 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7117
7118 static int ixj_get_status_proc(char *buf)
7119 {
7120 int len;
7121 int cnt;
7122 IXJ *j;
7123 len = 0;
7124 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7125 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7126 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7127 len += sprintf(buf + len, "\nUsing old telephony API");
7128 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7129
7130 for (cnt = 0; cnt < IXJMAX; cnt++) {
7131 j = get_ixj(cnt);
7132 if(j==NULL)
7133 continue;
7134 if (j->DSPbase) {
7135 len += sprintf(buf + len, "\nCard Num %d", cnt);
7136 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7137 if (j->cardtype != QTI_PHONEJACK)
7138 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7139 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7140 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7141 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7142 switch (j->cardtype) {
7143 case (QTI_PHONEJACK):
7144 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7145 break;
7146 case (QTI_LINEJACK):
7147 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7148 if (j->flags.g729_loaded)
7149 len += sprintf(buf + len, " w/G.729 A/B");
7150 len += sprintf(buf + len, " Country = %d", j->daa_country);
7151 break;
7152 case (QTI_PHONEJACK_LITE):
7153 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7154 if (j->flags.g729_loaded)
7155 len += sprintf(buf + len, " w/G.729 A/B");
7156 break;
7157 case (QTI_PHONEJACK_PCI):
7158 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7159 if (j->flags.g729_loaded)
7160 len += sprintf(buf + len, " w/G.729 A/B");
7161 break;
7162 case (QTI_PHONECARD):
7163 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7164 if (j->flags.g729_loaded)
7165 len += sprintf(buf + len, " w/G.729 A/B");
7166 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7167 if (!j->pccr1.bits.drf)
7168 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7169 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7170 break;
7171 default:
7172 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7173 break;
7174 }
7175 len += sprintf(buf + len, "\nReaders %d", j->readers);
7176 len += sprintf(buf + len, "\nWriters %d", j->writers);
7177 add_caps(j);
7178 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7179 if (j->dsp.low != 0x20)
7180 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7181 if (j->flags.cidsent)
7182 len += sprintf(buf + len, "\nCaller ID data sent");
7183 else
7184 len += sprintf(buf + len, "\nCaller ID data not sent");
7185
7186 len += sprintf(buf + len, "\nPlay CODEC ");
7187 switch (j->play_codec) {
7188 case G723_63:
7189 len += sprintf(buf + len, "G.723.1 6.3");
7190 break;
7191 case G723_53:
7192 len += sprintf(buf + len, "G.723.1 5.3");
7193 break;
7194 case TS85:
7195 len += sprintf(buf + len, "TrueSpeech 8.5");
7196 break;
7197 case TS48:
7198 len += sprintf(buf + len, "TrueSpeech 4.8");
7199 break;
7200 case TS41:
7201 len += sprintf(buf + len, "TrueSpeech 4.1");
7202 break;
7203 case G728:
7204 len += sprintf(buf + len, "G.728");
7205 break;
7206 case G729:
7207 len += sprintf(buf + len, "G.729");
7208 break;
7209 case G729B:
7210 len += sprintf(buf + len, "G.729B");
7211 break;
7212 case ULAW:
7213 len += sprintf(buf + len, "uLaw");
7214 break;
7215 case ALAW:
7216 len += sprintf(buf + len, "aLaw");
7217 break;
7218 case LINEAR16:
7219 len += sprintf(buf + len, "16 bit Linear");
7220 break;
7221 case LINEAR8:
7222 len += sprintf(buf + len, "8 bit Linear");
7223 break;
7224 case WSS:
7225 len += sprintf(buf + len, "Windows Sound System");
7226 break;
7227 default:
7228 len += sprintf(buf + len, "NO CODEC CHOSEN");
7229 break;
7230 }
7231 len += sprintf(buf + len, "\nRecord CODEC ");
7232 switch (j->rec_codec) {
7233 case G723_63:
7234 len += sprintf(buf + len, "G.723.1 6.3");
7235 break;
7236 case G723_53:
7237 len += sprintf(buf + len, "G.723.1 5.3");
7238 break;
7239 case TS85:
7240 len += sprintf(buf + len, "TrueSpeech 8.5");
7241 break;
7242 case TS48:
7243 len += sprintf(buf + len, "TrueSpeech 4.8");
7244 break;
7245 case TS41:
7246 len += sprintf(buf + len, "TrueSpeech 4.1");
7247 break;
7248 case G728:
7249 len += sprintf(buf + len, "G.728");
7250 break;
7251 case G729:
7252 len += sprintf(buf + len, "G.729");
7253 break;
7254 case G729B:
7255 len += sprintf(buf + len, "G.729B");
7256 break;
7257 case ULAW:
7258 len += sprintf(buf + len, "uLaw");
7259 break;
7260 case ALAW:
7261 len += sprintf(buf + len, "aLaw");
7262 break;
7263 case LINEAR16:
7264 len += sprintf(buf + len, "16 bit Linear");
7265 break;
7266 case LINEAR8:
7267 len += sprintf(buf + len, "8 bit Linear");
7268 break;
7269 case WSS:
7270 len += sprintf(buf + len, "Windows Sound System");
7271 break;
7272 default:
7273 len += sprintf(buf + len, "NO CODEC CHOSEN");
7274 break;
7275 }
7276 len += sprintf(buf + len, "\nAEC ");
7277 switch (j->aec_level) {
7278 case AEC_OFF:
7279 len += sprintf(buf + len, "Off");
7280 break;
7281 case AEC_LOW:
7282 len += sprintf(buf + len, "Low");
7283 break;
7284 case AEC_MED:
7285 len += sprintf(buf + len, "Med");
7286 break;
7287 case AEC_HIGH:
7288 len += sprintf(buf + len, "High");
7289 break;
7290 case AEC_AUTO:
7291 len += sprintf(buf + len, "Auto");
7292 break;
7293 case AEC_AGC:
7294 len += sprintf(buf + len, "AEC/AGC");
7295 break;
7296 default:
7297 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7298 break;
7299 }
7300
7301 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7302 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7303 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7304
7305 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7306
7307 if (j->cardtype == QTI_LINEJACK) {
7308 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7309 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7310 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7311 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7312 switch (j->daa_mode) {
7313 case SOP_PU_SLEEP:
7314 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7315 break;
7316 case SOP_PU_RINGING:
7317 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7318 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7319 break;
7320 case SOP_PU_CONVERSATION:
7321 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7322 break;
7323 case SOP_PU_PULSEDIALING:
7324 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7325 break;
7326 }
7327 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7328 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7329 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7330 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7331 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7332 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7333 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7334 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7335 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7336 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7337 }
7338 switch (j->port) {
7339 case PORT_POTS:
7340 len += sprintf(buf + len, "\nPort POTS");
7341 break;
7342 case PORT_PSTN:
7343 len += sprintf(buf + len, "\nPort PSTN");
7344 break;
7345 case PORT_SPEAKER:
7346 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7347 break;
7348 case PORT_HANDSET:
7349 len += sprintf(buf + len, "\nPort HANDSET");
7350 break;
7351 }
7352 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7353 len += sprintf(buf + len, "\nSLIC state ");
7354 switch (SLIC_GetState(j)) {
7355 case PLD_SLIC_STATE_OC:
7356 len += sprintf(buf + len, "OC");
7357 break;
7358 case PLD_SLIC_STATE_RINGING:
7359 len += sprintf(buf + len, "RINGING");
7360 break;
7361 case PLD_SLIC_STATE_ACTIVE:
7362 len += sprintf(buf + len, "ACTIVE");
7363 break;
7364 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7365 len += sprintf(buf + len, "OHT");
7366 break;
7367 case PLD_SLIC_STATE_TIPOPEN:
7368 len += sprintf(buf + len, "TIPOPEN");
7369 break;
7370 case PLD_SLIC_STATE_STANDBY:
7371 len += sprintf(buf + len, "STANDBY");
7372 break;
7373 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7374 len += sprintf(buf + len, "APR");
7375 break;
7376 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7377 len += sprintf(buf + len, "OHTPR");
7378 break;
7379 default:
7380 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7381 break;
7382 }
7383 }
7384 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7385 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7386 #ifdef PERFMON_STATS
7387 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7388 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7389 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7390 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7391 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7392 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7393 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7394 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7395 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7396 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7397 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7398 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7399 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7400 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7401
7402 #endif
7403 len += sprintf(buf + len, "\n");
7404 }
7405 }
7406 return len;
7407 }
7408
7409 static int ixj_read_proc(char *page, char **start, off_t off,
7410 int count, int *eof, void *data)
7411 {
7412 int len = ixj_get_status_proc(page);
7413 if (len <= off+count) *eof = 1;
7414 *start = page + off;
7415 len -= off;
7416 if (len>count) len = count;
7417 if (len<0) len = 0;
7418 return len;
7419 }
7420
7421
7422 static void cleanup(void)
7423 {
7424 int cnt;
7425 IXJ *j;
7426
7427 for (cnt = 0; cnt < IXJMAX; cnt++) {
7428 j = get_ixj(cnt);
7429 if(j != NULL && j->DSPbase) {
7430 if (ixjdebug & 0x0002)
7431 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7432 del_timer(&j->timer);
7433 if (j->cardtype == QTI_LINEJACK) {
7434 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7435
7436 outb_p(j->pld_scrw.byte, j->XILINXbase);
7437 j->pld_slicw.bits.rly1 = 0;
7438 j->pld_slicw.bits.rly2 = 0;
7439 j->pld_slicw.bits.rly3 = 0;
7440 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7441 LED_SetState(0x0, j);
7442 if (ixjdebug & 0x0002)
7443 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7444 release_region(j->XILINXbase, 8);
7445 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7446 if (ixjdebug & 0x0002)
7447 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7448 release_region(j->XILINXbase, 4);
7449 }
7450 kfree(j->read_buffer);
7451 kfree(j->write_buffer);
7452 if (j->dev)
7453 pnp_device_detach(j->dev);
7454 if (ixjdebug & 0x0002)
7455 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7456 phone_unregister_device(&j->p);
7457 if (ixjdebug & 0x0002)
7458 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7459 release_region(j->DSPbase, 16);
7460 #ifdef IXJ_DYN_ALLOC
7461 if (ixjdebug & 0x0002)
7462 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7463 kfree(j);
7464 ixj[cnt] = NULL;
7465 #endif
7466 }
7467 }
7468 if (ixjdebug & 0x0002)
7469 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7470 remove_proc_entry ("ixj", NULL);
7471 }
7472
7473 /* Typedefs */
7474 typedef struct {
7475 BYTE length;
7476 DWORD bits;
7477 } DATABLOCK;
7478
7479 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7480 {
7481 lastLCC = lastLCC & 0xfb;
7482 lastLCC = lastLCC | (byData ? 4 : 0);
7483 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7484
7485 mdelay(1);
7486 lastLCC = lastLCC | 0x01;
7487 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7488
7489 byData = byData << 1;
7490 lastLCC = lastLCC & 0xfe;
7491 mdelay(1);
7492 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7493
7494 }
7495
7496 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7497 {
7498 mdelay(1);
7499 lastLCC = lastLCC | 0x01;
7500 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7501
7502 lastLCC = lastLCC & 0xfe;
7503 mdelay(1);
7504 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7505
7506 return ((inb(wEEPROMAddress) >> 3) & 1);
7507 }
7508
7509 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7510 {
7511 BYTE lastLCC;
7512 WORD wEEPROMAddress = wAddress + 3;
7513 DWORD i;
7514 BYTE byResult;
7515 *pwResult = 0;
7516 lastLCC = inb(wEEPROMAddress);
7517 lastLCC = lastLCC | 0x02;
7518 lastLCC = lastLCC & 0xfe;
7519 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7520
7521 mdelay(1); /* delay */
7522
7523 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7524 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7525 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7526 for (i = 0; i < 8; i++) {
7527 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7528 wLoc <<= 1;
7529 }
7530
7531 for (i = 0; i < 16; i++) {
7532 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7533 *pwResult = (*pwResult << 1) | byResult;
7534 }
7535
7536 mdelay(1); /* another delay */
7537
7538 lastLCC = lastLCC & 0xfd;
7539 outb(lastLCC, wEEPROMAddress); /* negate CS */
7540
7541 return 0;
7542 }
7543
7544 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7545 {
7546 WORD wLo, wHi;
7547 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7548 return 0;
7549 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7550 return 0;
7551 return (((DWORD) wHi << 16) | wLo);
7552 }
7553
7554 static int dspio[IXJMAX + 1] =
7555 {
7556 0,
7557 };
7558 static int xio[IXJMAX + 1] =
7559 {
7560 0,
7561 };
7562
7563 module_param_array(dspio, int, NULL, 0);
7564 module_param_array(xio, int, NULL, 0);
7565 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7566 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7567 MODULE_LICENSE("GPL");
7568
7569 static void __exit ixj_exit(void)
7570 {
7571 cleanup();
7572 }
7573
7574 static IXJ *new_ixj(unsigned long port)
7575 {
7576 IXJ *res;
7577 if (!request_region(port, 16, "ixj DSP")) {
7578 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7579 return NULL;
7580 }
7581 res = ixj_alloc();
7582 if (!res) {
7583 release_region(port, 16);
7584 printk(KERN_INFO "ixj: out of memory\n");
7585 return NULL;
7586 }
7587 res->DSPbase = port;
7588 return res;
7589 }
7590
7591 static int __init ixj_probe_isapnp(int *cnt)
7592 {
7593 int probe = 0;
7594 int func = 0x110;
7595 struct pnp_dev *dev = NULL, *old_dev = NULL;
7596
7597 while (1) {
7598 do {
7599 IXJ *j;
7600 int result;
7601
7602 old_dev = dev;
7603 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7604 ISAPNP_FUNCTION(func), old_dev);
7605 if (!dev || !dev->card)
7606 break;
7607 result = pnp_device_attach(dev);
7608 if (result < 0) {
7609 printk("pnp attach failed %d \n", result);
7610 break;
7611 }
7612 if (pnp_activate_dev(dev) < 0) {
7613 printk("pnp activate failed (out of resources?)\n");
7614 pnp_device_detach(dev);
7615 return -ENOMEM;
7616 }
7617
7618 if (!pnp_port_valid(dev, 0)) {
7619 pnp_device_detach(dev);
7620 return -ENODEV;
7621 }
7622
7623 j = new_ixj(pnp_port_start(dev, 0));
7624 if (!j)
7625 break;
7626
7627 if (func != 0x110)
7628 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7629
7630 switch (func) {
7631 case (0x110):
7632 j->cardtype = QTI_PHONEJACK;
7633 break;
7634 case (0x310):
7635 j->cardtype = QTI_LINEJACK;
7636 break;
7637 case (0x410):
7638 j->cardtype = QTI_PHONEJACK_LITE;
7639 break;
7640 }
7641 j->board = *cnt;
7642 probe = ixj_selfprobe(j);
7643 if(!probe) {
7644 j->serial = dev->card->serial;
7645 j->dev = dev;
7646 switch (func) {
7647 case 0x110:
7648 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7649 break;
7650 case 0x310:
7651 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7652 break;
7653 case 0x410:
7654 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7655 break;
7656 }
7657 }
7658 ++*cnt;
7659 } while (dev);
7660 if (func == 0x410)
7661 break;
7662 if (func == 0x310)
7663 func = 0x410;
7664 if (func == 0x110)
7665 func = 0x310;
7666 dev = NULL;
7667 }
7668 return probe;
7669 }
7670
7671 static int __init ixj_probe_isa(int *cnt)
7672 {
7673 int i, probe;
7674
7675 /* Use passed parameters for older kernels without PnP */
7676 for (i = 0; i < IXJMAX; i++) {
7677 if (dspio[i]) {
7678 IXJ *j = new_ixj(dspio[i]);
7679
7680 if (!j)
7681 break;
7682
7683 j->XILINXbase = xio[i];
7684 j->cardtype = 0;
7685
7686 j->board = *cnt;
7687 probe = ixj_selfprobe(j);
7688 j->dev = NULL;
7689 ++*cnt;
7690 }
7691 }
7692 return 0;
7693 }
7694
7695 static int __init ixj_probe_pci(int *cnt)
7696 {
7697 struct pci_dev *pci = NULL;
7698 int i, probe = 0;
7699 IXJ *j = NULL;
7700
7701 for (i = 0; i < IXJMAX - *cnt; i++) {
7702 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7703 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7704 if (!pci)
7705 break;
7706
7707 if (pci_enable_device(pci))
7708 break;
7709 j = new_ixj(pci_resource_start(pci, 0));
7710 if (!j)
7711 break;
7712
7713 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7714 j->XILINXbase = j->DSPbase + 0x10;
7715 j->cardtype = QTI_PHONEJACK_PCI;
7716 j->board = *cnt;
7717 probe = ixj_selfprobe(j);
7718 if (!probe)
7719 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7720 ++*cnt;
7721 }
7722 pci_dev_put(pci);
7723 return probe;
7724 }
7725
7726 static int __init ixj_init(void)
7727 {
7728 int cnt = 0;
7729 int probe = 0;
7730
7731 cnt = 0;
7732
7733 /* These might be no-ops, see above. */
7734 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7735 return probe;
7736 }
7737 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7738 return probe;
7739 }
7740 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7741 return probe;
7742 }
7743 printk(KERN_INFO "ixj driver initialized.\n");
7744 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7745 return probe;
7746 }
7747
7748 module_init(ixj_init);
7749 module_exit(ixj_exit);
7750
7751 static void DAA_Coeff_US(IXJ *j)
7752 {
7753 int i;
7754
7755 j->daa_country = DAA_US;
7756 /*----------------------------------------------- */
7757 /* CAO */
7758 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7759 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7760 }
7761
7762 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7771 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7778 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7779 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7780 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7789 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7796 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7797 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7798 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7799 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7800 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7801 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7802 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7803 /* Bytes for AR-filter (09): 52,D3,11,42 */
7804 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7805 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7806 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7807 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7808 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7817 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7826 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7833 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7834 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7835 /* ; (10K, 0.68uF) */
7836 /* */
7837 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7846 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7853 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7854 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7855
7856 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7857 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7858 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7859 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7860 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7861
7862 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7863 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7864 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7865 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7866 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7867 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7868 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7869 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7870 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7871 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7872 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7876 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7877 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7878 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7879 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7880 /* */
7881 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7884 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7885 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7886
7887 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7896 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7903 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7904 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7905 /* */
7906 /* ;CR Registers */
7907 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7909 /* Config. Reg. 1 (dialing) (cr1):05 */
7910 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7911 /* Config. Reg. 2 (caller ID) (cr2):04 */
7912 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7913 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7915 /* Config. Reg. 4 (analog gain) (cr4):02 */
7916 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7917 /* Config. Reg. 5 (Version) (cr5):02 */
7918 /* Config. Reg. 6 (Reserved) (cr6):00 */
7919 /* Config. Reg. 7 (Reserved) (cr7):00 */
7920 /* */
7921 /* ;xr Registers */
7922 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7923
7924 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7925 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7926
7927 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7928 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7929 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7930 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7931 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7932 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7933
7934 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7935 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7936 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7937 /* Ext. Reg. 6 (Power State) (xr6):00 */
7938 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7939 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7940 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7941 /* */
7942 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7943 /* 12,33,5A,C3 ; 770 Hz */
7944 /* 13,3C,5B,32 ; 852 Hz */
7945 /* 1D,1B,5C,CC ; 941 Hz */
7946
7947 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7950 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7951 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7952 /* EC,1D,52,22 ; 1336 Hz */
7953 /* AA,AC,51,D2 ; 1477 Hz */
7954 /* 9B,3B,51,25 ; 1633 Hz */
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7957 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7958 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7959 }
7960
7961 static void DAA_Coeff_UK(IXJ *j)
7962 {
7963 int i;
7964
7965 j->daa_country = DAA_UK;
7966 /*----------------------------------------------- */
7967 /* CAO */
7968 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7969 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7970 }
7971
7972 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7981 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7988 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7989 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7990 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7999 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8006 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8007 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8008 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8009 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8010 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8011 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8012 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8013 /* Bytes for AR-filter (09): E2,27,10,D6 */
8014 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8015 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8016 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8017 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8018 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8027 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8036 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8043 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8044 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8045 /* ; idle */
8046 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8055 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8062 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8063 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8064 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8065 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8066 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8067 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8068 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8069 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8078 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8085 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8086 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8087 /* ;CR Registers */
8088 /* Config. Reg. 0 (filters) (cr0):FF */
8089 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8090 /* Config. Reg. 1 (dialing) (cr1):05 */
8091 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8092 /* Config. Reg. 2 (caller ID) (cr2):04 */
8093 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8094 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8095 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8096 /* Config. Reg. 4 (analog gain) (cr4):02 */
8097 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8098 /* Config. Reg. 5 (Version) (cr5):02 */
8099 /* Config. Reg. 6 (Reserved) (cr6):00 */
8100 /* Config. Reg. 7 (Reserved) (cr7):00 */
8101 /* ;xr Registers */
8102 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8103
8104 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8105 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8106
8107 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8108 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8109
8110 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8111 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8112 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8113 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8114 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8115 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8116 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8117 /* Ext. Reg. 6 (Power State) (xr6):00 */
8118 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8119 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8120 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8121 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8122 /* 12,33,5A,C3 ; 770 Hz */
8123 /* 13,3C,5B,32 ; 852 Hz */
8124 /* 1D,1B,5C,CC ; 941 Hz */
8125
8126 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8129 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8130 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8131 /* EC,1D,52,22 ; 1336 Hz */
8132 /* AA,AC,51,D2 ; 1477 Hz */
8133 /* 9B,3B,51,25 ; 1633 Hz */
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8136 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8137 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8138 }
8139
8140
8141 static void DAA_Coeff_France(IXJ *j)
8142 {
8143 int i;
8144
8145 j->daa_country = DAA_FRANCE;
8146 /*----------------------------------------------- */
8147 /* CAO */
8148 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8149 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8150 }
8151
8152 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8161 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8168 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8169 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8170 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8179 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8186 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8187 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8188 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8189 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8190 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8191 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8192 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8193 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8194 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8195 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8196 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8197 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8198 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8207 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8216 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8223 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8224 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8225 /* ; idle */
8226 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8235 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8242 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8243 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8244 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8245 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8246 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8247 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8248 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8249 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8258 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8265 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8266 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8267 /* ;CR Registers */
8268 /* Config. Reg. 0 (filters) (cr0):FF */
8269 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8270 /* Config. Reg. 1 (dialing) (cr1):05 */
8271 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8272 /* Config. Reg. 2 (caller ID) (cr2):04 */
8273 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8274 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8275 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8276 /* Config. Reg. 4 (analog gain) (cr4):02 */
8277 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8278 /* Config. Reg. 5 (Version) (cr5):02 */
8279 /* Config. Reg. 6 (Reserved) (cr6):00 */
8280 /* Config. Reg. 7 (Reserved) (cr7):00 */
8281 /* ;xr Registers */
8282 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8283
8284 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8285 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8286
8287 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8288 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8289
8290 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8291 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8292 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8293 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8294 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8295 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8296 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8297 /* Ext. Reg. 6 (Power State) (xr6):00 */
8298 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8299 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8300 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8301 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8302 /* 12,33,5A,C3 ; 770 Hz */
8303 /* 13,3C,5B,32 ; 852 Hz */
8304 /* 1D,1B,5C,CC ; 941 Hz */
8305
8306 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8309 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8310 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8311 /* EC,1D,52,22 ; 1336 Hz */
8312 /* AA,AC,51,D2 ; 1477 Hz */
8313 /* 9B,3B,51,25 ; 1633 Hz */
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8316 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8317 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8318 }
8319
8320
8321 static void DAA_Coeff_Germany(IXJ *j)
8322 {
8323 int i;
8324
8325 j->daa_country = DAA_GERMANY;
8326 /*----------------------------------------------- */
8327 /* CAO */
8328 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8329 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8330 }
8331
8332 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8341 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8348 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8349 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8350 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8359 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8366 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8367 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8368 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8369 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8370 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8371 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8372 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8373 /* Bytes for AR-filter (09): 72,42,13,4B */
8374 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8375 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8376 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8377 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8378 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8387 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8396 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8403 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8404 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8405 /* ; (10K, 0.68uF) */
8406 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8415 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8422 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8423 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8424 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8425 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8426 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8427 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8428 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8429 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8438 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8445 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8446 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8447 /* ;CR Registers */
8448 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8449 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8450 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8451 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8452 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8453 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8454 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8455 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8456 /* Config. Reg. 4 (analog gain) (cr4):02 */
8457 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8458 /* Config. Reg. 5 (Version) (cr5):02 */
8459 /* Config. Reg. 6 (Reserved) (cr6):00 */
8460 /* Config. Reg. 7 (Reserved) (cr7):00 */
8461 /* ;xr Registers */
8462 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8463
8464 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8465 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8466
8467 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8468 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8469
8470 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8471 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8472 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8473 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8474 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8475 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8476 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8477 /* Ext. Reg. 6 (Power State) (xr6):00 */
8478 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8479 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8480 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8481 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8482 /* 12,33,5A,C3 ; 770 Hz */
8483 /* 13,3C,5B,32 ; 852 Hz */
8484 /* 1D,1B,5C,CC ; 941 Hz */
8485
8486 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8489 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8490 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8491 /* EC,1D,52,22 ; 1336 Hz */
8492 /* AA,AC,51,D2 ; 1477 Hz */
8493 /* 9B,3B,51,25 ; 1633 Hz */
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8496 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8497 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8498 }
8499
8500
8501 static void DAA_Coeff_Australia(IXJ *j)
8502 {
8503 int i;
8504
8505 j->daa_country = DAA_AUSTRALIA;
8506 /*----------------------------------------------- */
8507 /* CAO */
8508 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8509 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8510 }
8511
8512 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8521 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8528 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8529 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8530 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8539 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8546 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8547 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8548 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8549 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8550 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8551 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8552 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8553 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8554 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8555 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8556 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8557 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8558 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8567 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8576 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8583 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8584 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8585 /* ; idle */
8586 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8595 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8602 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8603 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8604 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8605 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8606 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8607 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8608 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8609 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8618 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8625 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8626 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8627 /* ;CR Registers */
8628 /* Config. Reg. 0 (filters) (cr0):FF */
8629 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8630 /* Config. Reg. 1 (dialing) (cr1):05 */
8631 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8632 /* Config. Reg. 2 (caller ID) (cr2):04 */
8633 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8634 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8635 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8636 /* Config. Reg. 4 (analog gain) (cr4):02 */
8637 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8638 /* Config. Reg. 5 (Version) (cr5):02 */
8639 /* Config. Reg. 6 (Reserved) (cr6):00 */
8640 /* Config. Reg. 7 (Reserved) (cr7):00 */
8641 /* ;xr Registers */
8642 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8643
8644 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8645 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8646
8647 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8648 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8649
8650 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8651 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8652 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8653 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8654 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8655 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8656 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8657 /* Ext. Reg. 6 (Power State) (xr6):00 */
8658 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8659 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8660 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8661
8662 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8663 /* 12,33,5A,C3 ; 770 Hz */
8664 /* 13,3C,5B,32 ; 852 Hz */
8665 /* 1D,1B,5C,CC ; 941 Hz */
8666 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8668 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8669 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8670
8671 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8672 /* EC,1D,52,22 ; 1336 Hz */
8673 /* AA,AC,51,D2 ; 1477 Hz */
8674 /* 9B,3B,51,25 ; 1633 Hz */
8675 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8677 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8678 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8679 }
8680
8681 static void DAA_Coeff_Japan(IXJ *j)
8682 {
8683 int i;
8684
8685 j->daa_country = DAA_JAPAN;
8686 /*----------------------------------------------- */
8687 /* CAO */
8688 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8689 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8690 }
8691
8692 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8701 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8708 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8709 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8710 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8719 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8726 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8727 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8728 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8729 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8730 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8731 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8732 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8733 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8734 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8735 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8736 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8737 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8738 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8747 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8756 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8763 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8764 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8765 /* ; idle */
8766 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8775 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8782 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8783 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8784 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8785 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8786 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8787 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8788 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8789 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8798 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8805 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8806 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8807 /* ;CR Registers */
8808 /* Config. Reg. 0 (filters) (cr0):FF */
8809 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8810 /* Config. Reg. 1 (dialing) (cr1):05 */
8811 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8812 /* Config. Reg. 2 (caller ID) (cr2):04 */
8813 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8814 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8815 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8816 /* Config. Reg. 4 (analog gain) (cr4):02 */
8817 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8818 /* Config. Reg. 5 (Version) (cr5):02 */
8819 /* Config. Reg. 6 (Reserved) (cr6):00 */
8820 /* Config. Reg. 7 (Reserved) (cr7):00 */
8821 /* ;xr Registers */
8822 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8823
8824 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8825 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8826
8827 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8828 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8829
8830 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8831 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8832 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8833 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8834 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8835 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8836 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8837 /* Ext. Reg. 6 (Power State) (xr6):00 */
8838 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8839 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8840 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8841 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8842 /* 12,33,5A,C3 ; 770 Hz */
8843 /* 13,3C,5B,32 ; 852 Hz */
8844 /* 1D,1B,5C,CC ; 941 Hz */
8845
8846 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8849 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8850 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8851 /* EC,1D,52,22 ; 1336 Hz */
8852 /* AA,AC,51,D2 ; 1477 Hz */
8853 /* 9B,3B,51,25 ; 1633 Hz */
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8856 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8857 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8858 }
8859
8860 static s16 tone_table[][19] =
8861 {
8862 { /* f20_50[] 11 */
8863 32538, /* A1 = 1.985962 */
8864 -32325, /* A2 = -0.986511 */
8865 -343, /* B2 = -0.010493 */
8866 0, /* B1 = 0 */
8867 343, /* B0 = 0.010493 */
8868 32619, /* A1 = 1.990906 */
8869 -32520, /* A2 = -0.992462 */
8870 19179, /* B2 = 0.585327 */
8871 -19178, /* B1 = -1.170593 */
8872 19179, /* B0 = 0.585327 */
8873 32723, /* A1 = 1.997314 */
8874 -32686, /* A2 = -0.997528 */
8875 9973, /* B2 = 0.304352 */
8876 -9955, /* B1 = -0.607605 */
8877 9973, /* B0 = 0.304352 */
8878 7, /* Internal filter scaling */
8879 159, /* Minimum in-band energy threshold */
8880 21, /* 21/32 in-band to broad-band ratio */
8881 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8882 },
8883 { /* f133_200[] 12 */
8884 32072, /* A1 = 1.95752 */
8885 -31896, /* A2 = -0.973419 */
8886 -435, /* B2 = -0.013294 */
8887 0, /* B1 = 0 */
8888 435, /* B0 = 0.013294 */
8889 32188, /* A1 = 1.9646 */
8890 -32400, /* A2 = -0.98877 */
8891 15139, /* B2 = 0.462036 */
8892 -14882, /* B1 = -0.908356 */
8893 15139, /* B0 = 0.462036 */
8894 32473, /* A1 = 1.981995 */
8895 -32524, /* A2 = -0.992584 */
8896 23200, /* B2 = 0.708008 */
8897 -23113, /* B1 = -1.410706 */
8898 23200, /* B0 = 0.708008 */
8899 7, /* Internal filter scaling */
8900 159, /* Minimum in-band energy threshold */
8901 21, /* 21/32 in-band to broad-band ratio */
8902 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8903 },
8904 { /* f300 13 */
8905 31769, /* A1 = -1.939026 */
8906 -32584, /* A2 = 0.994385 */
8907 -475, /* B2 = -0.014522 */
8908 0, /* B1 = 0.000000 */
8909 475, /* B0 = 0.014522 */
8910 31789, /* A1 = -1.940247 */
8911 -32679, /* A2 = 0.997284 */
8912 17280, /* B2 = 0.527344 */
8913 -16865, /* B1 = -1.029358 */
8914 17280, /* B0 = 0.527344 */
8915 31841, /* A1 = -1.943481 */
8916 -32681, /* A2 = 0.997345 */
8917 543, /* B2 = 0.016579 */
8918 -525, /* B1 = -0.032097 */
8919 543, /* B0 = 0.016579 */
8920 5, /* Internal filter scaling */
8921 159, /* Minimum in-band energy threshold */
8922 21, /* 21/32 in-band to broad-band ratio */
8923 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8924 },
8925 { /* f300_420[] 14 */
8926 30750, /* A1 = 1.876892 */
8927 -31212, /* A2 = -0.952515 */
8928 -804, /* B2 = -0.024541 */
8929 0, /* B1 = 0 */
8930 804, /* B0 = 0.024541 */
8931 30686, /* A1 = 1.872925 */
8932 -32145, /* A2 = -0.980988 */
8933 14747, /* B2 = 0.450043 */
8934 -13703, /* B1 = -0.836395 */
8935 14747, /* B0 = 0.450043 */
8936 31651, /* A1 = 1.931824 */
8937 -32321, /* A2 = -0.986389 */
8938 24425, /* B2 = 0.745422 */
8939 -23914, /* B1 = -1.459595 */
8940 24427, /* B0 = 0.745483 */
8941 7, /* Internal filter scaling */
8942 159, /* Minimum in-band energy threshold */
8943 21, /* 21/32 in-band to broad-band ratio */
8944 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8945 },
8946 { /* f330 15 */
8947 31613, /* A1 = -1.929565 */
8948 -32646, /* A2 = 0.996277 */
8949 -185, /* B2 = -0.005657 */
8950 0, /* B1 = 0.000000 */
8951 185, /* B0 = 0.005657 */
8952 31620, /* A1 = -1.929932 */
8953 -32713, /* A2 = 0.998352 */
8954 19253, /* B2 = 0.587585 */
8955 -18566, /* B1 = -1.133179 */
8956 19253, /* B0 = 0.587585 */
8957 31674, /* A1 = -1.933228 */
8958 -32715, /* A2 = 0.998413 */
8959 2575, /* B2 = 0.078590 */
8960 -2495, /* B1 = -0.152283 */
8961 2575, /* B0 = 0.078590 */
8962 5, /* Internal filter scaling */
8963 159, /* Minimum in-band energy threshold */
8964 21, /* 21/32 in-band to broad-band ratio */
8965 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8966 },
8967 { /* f300_425[] 16 */
8968 30741, /* A1 = 1.876282 */
8969 -31475, /* A2 = -0.960541 */
8970 -703, /* B2 = -0.021484 */
8971 0, /* B1 = 0 */
8972 703, /* B0 = 0.021484 */
8973 30688, /* A1 = 1.873047 */
8974 -32248, /* A2 = -0.984161 */
8975 14542, /* B2 = 0.443787 */
8976 -13523, /* B1 = -0.825439 */
8977 14542, /* B0 = 0.443817 */
8978 31494, /* A1 = 1.922302 */
8979 -32366, /* A2 = -0.987762 */
8980 21577, /* B2 = 0.658508 */
8981 -21013, /* B1 = -1.282532 */
8982 21577, /* B0 = 0.658508 */
8983 7, /* Internal filter scaling */
8984 159, /* Minimum in-band energy threshold */
8985 21, /* 21/32 in-band to broad-band ratio */
8986 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8987 },
8988 { /* f330_440[] 17 */
8989 30627, /* A1 = 1.869324 */
8990 -31338, /* A2 = -0.95636 */
8991 -843, /* B2 = -0.025749 */
8992 0, /* B1 = 0 */
8993 843, /* B0 = 0.025749 */
8994 30550, /* A1 = 1.864685 */
8995 -32221, /* A2 = -0.983337 */
8996 13594, /* B2 = 0.414886 */
8997 -12589, /* B1 = -0.768402 */
8998 13594, /* B0 = 0.414886 */
8999 31488, /* A1 = 1.921936 */
9000 -32358, /* A2 = -0.987518 */
9001 24684, /* B2 = 0.753296 */
9002 -24029, /* B1 = -1.466614 */
9003 24684, /* B0 = 0.753296 */
9004 7, /* Internal filter scaling */
9005 159, /* Minimum in-band energy threshold */
9006 21, /* 21/32 in-band to broad-band ratio */
9007 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9008 },
9009 { /* f340 18 */
9010 31546, /* A1 = -1.925476 */
9011 -32646, /* A2 = 0.996277 */
9012 -445, /* B2 = -0.013588 */
9013 0, /* B1 = 0.000000 */
9014 445, /* B0 = 0.013588 */
9015 31551, /* A1 = -1.925781 */
9016 -32713, /* A2 = 0.998352 */
9017 23884, /* B2 = 0.728882 */
9018 -22979, /* B1 = -1.402527 */
9019 23884, /* B0 = 0.728882 */
9020 31606, /* A1 = -1.929138 */
9021 -32715, /* A2 = 0.998413 */
9022 863, /* B2 = 0.026367 */
9023 -835, /* B1 = -0.050985 */
9024 863, /* B0 = 0.026367 */
9025 5, /* Internal filter scaling */
9026 159, /* Minimum in-band energy threshold */
9027 21, /* 21/32 in-band to broad-band ratio */
9028 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9029 },
9030 { /* f350_400[] 19 */
9031 31006, /* A1 = 1.892517 */
9032 -32029, /* A2 = -0.977448 */
9033 -461, /* B2 = -0.014096 */
9034 0, /* B1 = 0 */
9035 461, /* B0 = 0.014096 */
9036 30999, /* A1 = 1.892029 */
9037 -32487, /* A2 = -0.991455 */
9038 11325, /* B2 = 0.345612 */
9039 -10682, /* B1 = -0.651978 */
9040 11325, /* B0 = 0.345612 */
9041 31441, /* A1 = 1.919067 */
9042 -32526, /* A2 = -0.992615 */
9043 24324, /* B2 = 0.74231 */
9044 -23535, /* B1 = -1.436523 */
9045 24324, /* B0 = 0.74231 */
9046 7, /* Internal filter scaling */
9047 159, /* Minimum in-band energy threshold */
9048 21, /* 21/32 in-band to broad-band ratio */
9049 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9050 },
9051 { /* f350_440[] */
9052 30634, /* A1 = 1.869751 */
9053 -31533, /* A2 = -0.962341 */
9054 -680, /* B2 = -0.020782 */
9055 0, /* B1 = 0 */
9056 680, /* B0 = 0.020782 */
9057 30571, /* A1 = 1.865906 */
9058 -32277, /* A2 = -0.985016 */
9059 12894, /* B2 = 0.393524 */
9060 -11945, /* B1 = -0.729065 */
9061 12894, /* B0 = 0.393524 */
9062 31367, /* A1 = 1.91449 */
9063 -32379, /* A2 = -0.988129 */
9064 23820, /* B2 = 0.726929 */
9065 -23104, /* B1 = -1.410217 */
9066 23820, /* B0 = 0.726929 */
9067 7, /* Internal filter scaling */
9068 159, /* Minimum in-band energy threshold */
9069 21, /* 21/32 in-band to broad-band ratio */
9070 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9071 },
9072 { /* f350_450[] */
9073 30552, /* A1 = 1.864807 */
9074 -31434, /* A2 = -0.95929 */
9075 -690, /* B2 = -0.021066 */
9076 0, /* B1 = 0 */
9077 690, /* B0 = 0.021066 */
9078 30472, /* A1 = 1.859924 */
9079 -32248, /* A2 = -0.984161 */
9080 13385, /* B2 = 0.408478 */
9081 -12357, /* B1 = -0.754242 */
9082 13385, /* B0 = 0.408478 */
9083 31358, /* A1 = 1.914001 */
9084 -32366, /* A2 = -0.987732 */
9085 26488, /* B2 = 0.80835 */
9086 -25692, /* B1 = -1.568176 */
9087 26490, /* B0 = 0.808411 */
9088 7, /* Internal filter scaling */
9089 159, /* Minimum in-band energy threshold */
9090 21, /* 21/32 in-band to broad-band ratio */
9091 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9092 },
9093 { /* f360 */
9094 31397, /* A1 = -1.916321 */
9095 -32623, /* A2 = 0.995605 */
9096 -117, /* B2 = -0.003598 */
9097 0, /* B1 = 0.000000 */
9098 117, /* B0 = 0.003598 */
9099 31403, /* A1 = -1.916687 */
9100 -32700, /* A2 = 0.997925 */
9101 3388, /* B2 = 0.103401 */
9102 -3240, /* B1 = -0.197784 */
9103 3388, /* B0 = 0.103401 */
9104 31463, /* A1 = -1.920410 */
9105 -32702, /* A2 = 0.997986 */
9106 13346, /* B2 = 0.407288 */
9107 -12863, /* B1 = -0.785126 */
9108 13346, /* B0 = 0.407288 */
9109 5, /* Internal filter scaling */
9110 159, /* Minimum in-band energy threshold */
9111 21, /* 21/32 in-band to broad-band ratio */
9112 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9113 },
9114 { /* f380_420[] */
9115 30831, /* A1 = 1.881775 */
9116 -32064, /* A2 = -0.978546 */
9117 -367, /* B2 = -0.01122 */
9118 0, /* B1 = 0 */
9119 367, /* B0 = 0.01122 */
9120 30813, /* A1 = 1.880737 */
9121 -32456, /* A2 = -0.990509 */
9122 11068, /* B2 = 0.337769 */
9123 -10338, /* B1 = -0.631042 */
9124 11068, /* B0 = 0.337769 */
9125 31214, /* A1 = 1.905212 */
9126 -32491, /* A2 = -0.991577 */
9127 16374, /* B2 = 0.499695 */
9128 -15781, /* B1 = -0.963196 */
9129 16374, /* B0 = 0.499695 */
9130 7, /* Internal filter scaling */
9131 159, /* Minimum in-band energy threshold */
9132 21, /* 21/32 in-band to broad-band ratio */
9133 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9134 },
9135 { /* f392 */
9136 31152, /* A1 = -1.901428 */
9137 -32613, /* A2 = 0.995300 */
9138 -314, /* B2 = -0.009605 */
9139 0, /* B1 = 0.000000 */
9140 314, /* B0 = 0.009605 */
9141 31156, /* A1 = -1.901672 */
9142 -32694, /* A2 = 0.997742 */
9143 28847, /* B2 = 0.880371 */
9144 -2734, /* B1 = -0.166901 */
9145 28847, /* B0 = 0.880371 */
9146 31225, /* A1 = -1.905823 */
9147 -32696, /* A2 = 0.997803 */
9148 462, /* B2 = 0.014108 */
9149 -442, /* B1 = -0.027019 */
9150 462, /* B0 = 0.014108 */
9151 5, /* Internal filter scaling */
9152 159, /* Minimum in-band energy threshold */
9153 21, /* 21/32 in-band to broad-band ratio */
9154 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9155 },
9156 { /* f400_425[] */
9157 30836, /* A1 = 1.882141 */
9158 -32296, /* A2 = -0.985596 */
9159 -324, /* B2 = -0.009903 */
9160 0, /* B1 = 0 */
9161 324, /* B0 = 0.009903 */
9162 30825, /* A1 = 1.881409 */
9163 -32570, /* A2 = -0.993958 */
9164 16847, /* B2 = 0.51416 */
9165 -15792, /* B1 = -0.963898 */
9166 16847, /* B0 = 0.51416 */
9167 31106, /* A1 = 1.89856 */
9168 -32584, /* A2 = -0.994415 */
9169 9579, /* B2 = 0.292328 */
9170 -9164, /* B1 = -0.559357 */
9171 9579, /* B0 = 0.292328 */
9172 7, /* Internal filter scaling */
9173 159, /* Minimum in-band energy threshold */
9174 21, /* 21/32 in-band to broad-band ratio */
9175 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9176 },
9177 { /* f400_440[] */
9178 30702, /* A1 = 1.873962 */
9179 -32134, /* A2 = -0.980682 */
9180 -517, /* B2 = -0.015793 */
9181 0, /* B1 = 0 */
9182 517, /* B0 = 0.015793 */
9183 30676, /* A1 = 1.872375 */
9184 -32520, /* A2 = -0.992462 */
9185 8144, /* B2 = 0.24855 */
9186 -7596, /* B1 = -0.463684 */
9187 8144, /* B0 = 0.24855 */
9188 31084, /* A1 = 1.897217 */
9189 -32547, /* A2 = -0.993256 */
9190 22713, /* B2 = 0.693176 */
9191 -21734, /* B1 = -1.326599 */
9192 22713, /* B0 = 0.693176 */
9193 7, /* Internal filter scaling */
9194 159, /* Minimum in-band energy threshold */
9195 21, /* 21/32 in-band to broad-band ratio */
9196 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9197 },
9198 { /* f400_450[] */
9199 30613, /* A1 = 1.86853 */
9200 -32031, /* A2 = -0.977509 */
9201 -618, /* B2 = -0.018866 */
9202 0, /* B1 = 0 */
9203 618, /* B0 = 0.018866 */
9204 30577, /* A1 = 1.866272 */
9205 -32491, /* A2 = -0.991577 */
9206 9612, /* B2 = 0.293335 */
9207 -8935, /* B1 = -0.54541 */
9208 9612, /* B0 = 0.293335 */
9209 31071, /* A1 = 1.896484 */
9210 -32524, /* A2 = -0.992584 */
9211 21596, /* B2 = 0.659058 */
9212 -20667, /* B1 = -1.261414 */
9213 21596, /* B0 = 0.659058 */
9214 7, /* Internal filter scaling */
9215 159, /* Minimum in-band energy threshold */
9216 21, /* 21/32 in-band to broad-band ratio */
9217 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9218 },
9219 { /* f420 */
9220 30914, /* A1 = -1.886841 */
9221 -32584, /* A2 = 0.994385 */
9222 -426, /* B2 = -0.013020 */
9223 0, /* B1 = 0.000000 */
9224 426, /* B0 = 0.013020 */
9225 30914, /* A1 = -1.886841 */
9226 -32679, /* A2 = 0.997314 */
9227 17520, /* B2 = 0.534668 */
9228 -16471, /* B1 = -1.005310 */
9229 17520, /* B0 = 0.534668 */
9230 31004, /* A1 = -1.892334 */
9231 -32683, /* A2 = 0.997406 */
9232 819, /* B2 = 0.025023 */
9233 -780, /* B1 = -0.047619 */
9234 819, /* B0 = 0.025023 */
9235 5, /* Internal filter scaling */
9236 159, /* Minimum in-band energy threshold */
9237 21, /* 21/32 in-band to broad-band ratio */
9238 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9239 },
9240 #if 0
9241 { /* f425 */
9242 30881, /* A1 = -1.884827 */
9243 -32603, /* A2 = 0.994965 */
9244 -496, /* B2 = -0.015144 */
9245 0, /* B1 = 0.000000 */
9246 496, /* B0 = 0.015144 */
9247 30880, /* A1 = -1.884766 */
9248 -32692, /* A2 = 0.997711 */
9249 24767, /* B2 = 0.755859 */
9250 -23290, /* B1 = -1.421509 */
9251 24767, /* B0 = 0.755859 */
9252 30967, /* A1 = -1.890076 */
9253 -32694, /* A2 = 0.997772 */
9254 728, /* B2 = 0.022232 */
9255 -691, /* B1 = -0.042194 */
9256 728, /* B0 = 0.022232 */
9257 5, /* Internal filter scaling */
9258 159, /* Minimum in-band energy threshold */
9259 21, /* 21/32 in-band to broad-band ratio */
9260 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9261 },
9262 #else
9263 {
9264 30850,
9265 -32534,
9266 -504,
9267 0,
9268 504,
9269 30831,
9270 -32669,
9271 24303,
9272 -22080,
9273 24303,
9274 30994,
9275 -32673,
9276 1905,
9277 -1811,
9278 1905,
9279 5,
9280 129,
9281 17,
9282 0xff5
9283 },
9284 #endif
9285 { /* f425_450[] */
9286 30646, /* A1 = 1.870544 */
9287 -32327, /* A2 = -0.986572 */
9288 -287, /* B2 = -0.008769 */
9289 0, /* B1 = 0 */
9290 287, /* B0 = 0.008769 */
9291 30627, /* A1 = 1.869324 */
9292 -32607, /* A2 = -0.995087 */
9293 13269, /* B2 = 0.404968 */
9294 -12376, /* B1 = -0.755432 */
9295 13269, /* B0 = 0.404968 */
9296 30924, /* A1 = 1.887512 */
9297 -32619, /* A2 = -0.995453 */
9298 19950, /* B2 = 0.608826 */
9299 -18940, /* B1 = -1.156006 */
9300 19950, /* B0 = 0.608826 */
9301 7, /* Internal filter scaling */
9302 159, /* Minimum in-band energy threshold */
9303 21, /* 21/32 in-band to broad-band ratio */
9304 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9305 },
9306 { /* f425_475[] */
9307 30396, /* A1 = 1.855225 */
9308 -32014, /* A2 = -0.97699 */
9309 -395, /* B2 = -0.012055 */
9310 0, /* B1 = 0 */
9311 395, /* B0 = 0.012055 */
9312 30343, /* A1 = 1.85199 */
9313 -32482, /* A2 = -0.991302 */
9314 17823, /* B2 = 0.543945 */
9315 -16431, /* B1 = -1.002869 */
9316 17823, /* B0 = 0.543945 */
9317 30872, /* A1 = 1.884338 */
9318 -32516, /* A2 = -0.99231 */
9319 18124, /* B2 = 0.553101 */
9320 -17246, /* B1 = -1.052673 */
9321 18124, /* B0 = 0.553101 */
9322 7, /* Internal filter scaling */
9323 159, /* Minimum in-band energy threshold */
9324 21, /* 21/32 in-band to broad-band ratio */
9325 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9326 },
9327 { /* f435 */
9328 30796, /* A1 = -1.879639 */
9329 -32603, /* A2 = 0.994965 */
9330 -254, /* B2 = -0.007762 */
9331 0, /* B1 = 0.000000 */
9332 254, /* B0 = 0.007762 */
9333 30793, /* A1 = -1.879456 */
9334 -32692, /* A2 = 0.997711 */
9335 18934, /* B2 = 0.577820 */
9336 -17751, /* B1 = -1.083496 */
9337 18934, /* B0 = 0.577820 */
9338 30882, /* A1 = -1.884888 */
9339 -32694, /* A2 = 0.997772 */
9340 1858, /* B2 = 0.056713 */
9341 -1758, /* B1 = -0.107357 */
9342 1858, /* B0 = 0.056713 */
9343 5, /* Internal filter scaling */
9344 159, /* Minimum in-band energy threshold */
9345 21, /* 21/32 in-band to broad-band ratio */
9346 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9347 },
9348 { /* f440_450[] */
9349 30641, /* A1 = 1.870239 */
9350 -32458, /* A2 = -0.99057 */
9351 -155, /* B2 = -0.004735 */
9352 0, /* B1 = 0 */
9353 155, /* B0 = 0.004735 */
9354 30631, /* A1 = 1.869568 */
9355 -32630, /* A2 = -0.995789 */
9356 11453, /* B2 = 0.349548 */
9357 -10666, /* B1 = -0.651001 */
9358 11453, /* B0 = 0.349548 */
9359 30810, /* A1 = 1.880554 */
9360 -32634, /* A2 = -0.995941 */
9361 12237, /* B2 = 0.373474 */
9362 -11588, /* B1 = -0.707336 */
9363 12237, /* B0 = 0.373474 */
9364 7, /* Internal filter scaling */
9365 159, /* Minimum in-band energy threshold */
9366 21, /* 21/32 in-band to broad-band ratio */
9367 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9368 },
9369 { /* f440_480[] */
9370 30367, /* A1 = 1.853455 */
9371 -32147, /* A2 = -0.981079 */
9372 -495, /* B2 = -0.015113 */
9373 0, /* B1 = 0 */
9374 495, /* B0 = 0.015113 */
9375 30322, /* A1 = 1.850769 */
9376 -32543, /* A2 = -0.993134 */
9377 10031, /* B2 = 0.306152 */
9378 -9252, /* B1 = -0.564728 */
9379 10031, /* B0 = 0.306152 */
9380 30770, /* A1 = 1.878052 */
9381 -32563, /* A2 = -0.993774 */
9382 22674, /* B2 = 0.691956 */
9383 -21465, /* B1 = -1.31012 */
9384 22674, /* B0 = 0.691956 */
9385 7, /* Internal filter scaling */
9386 159, /* Minimum in-band energy threshold */
9387 21, /* 21/32 in-band to broad-band ratio */
9388 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9389 },
9390 { /* f445 */
9391 30709, /* A1 = -1.874329 */
9392 -32603, /* A2 = 0.994965 */
9393 -83, /* B2 = -0.002545 */
9394 0, /* B1 = 0.000000 */
9395 83, /* B0 = 0.002545 */
9396 30704, /* A1 = -1.874084 */
9397 -32692, /* A2 = 0.997711 */
9398 10641, /* B2 = 0.324738 */
9399 -9947, /* B1 = -0.607147 */
9400 10641, /* B0 = 0.324738 */
9401 30796, /* A1 = -1.879639 */
9402 -32694, /* A2 = 0.997772 */
9403 10079, /* B2 = 0.307587 */
9404 9513, /* B1 = 0.580688 */
9405 10079, /* B0 = 0.307587 */
9406 5, /* Internal filter scaling */
9407 159, /* Minimum in-band energy threshold */
9408 21, /* 21/32 in-band to broad-band ratio */
9409 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9410 },
9411 { /* f450 */
9412 30664, /* A1 = -1.871643 */
9413 -32603, /* A2 = 0.994965 */
9414 -164, /* B2 = -0.005029 */
9415 0, /* B1 = 0.000000 */
9416 164, /* B0 = 0.005029 */
9417 30661, /* A1 = -1.871399 */
9418 -32692, /* A2 = 0.997711 */
9419 15294, /* B2 = 0.466736 */
9420 -14275, /* B1 = -0.871307 */
9421 15294, /* B0 = 0.466736 */
9422 30751, /* A1 = -1.876953 */
9423 -32694, /* A2 = 0.997772 */
9424 3548, /* B2 = 0.108284 */
9425 -3344, /* B1 = -0.204155 */
9426 3548, /* B0 = 0.108284 */
9427 5, /* Internal filter scaling */
9428 159, /* Minimum in-band energy threshold */
9429 21, /* 21/32 in-band to broad-band ratio */
9430 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9431 },
9432 { /* f452 */
9433 30653, /* A1 = -1.870911 */
9434 -32615, /* A2 = 0.995361 */
9435 -209, /* B2 = -0.006382 */
9436 0, /* B1 = 0.000000 */
9437 209, /* B0 = 0.006382 */
9438 30647, /* A1 = -1.870605 */
9439 -32702, /* A2 = 0.997986 */
9440 18971, /* B2 = 0.578979 */
9441 -17716, /* B1 = -1.081299 */
9442 18971, /* B0 = 0.578979 */
9443 30738, /* A1 = -1.876099 */
9444 -32702, /* A2 = 0.998016 */
9445 2967, /* B2 = 0.090561 */
9446 -2793, /* B1 = -0.170502 */
9447 2967, /* B0 = 0.090561 */
9448 5, /* Internal filter scaling */
9449 159, /* Minimum in-band energy threshold */
9450 21, /* 21/32 in-band to broad-band ratio */
9451 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9452 },
9453 { /* f475 */
9454 30437, /* A1 = -1.857727 */
9455 -32603, /* A2 = 0.994965 */
9456 -264, /* B2 = -0.008062 */
9457 0, /* B1 = 0.000000 */
9458 264, /* B0 = 0.008062 */
9459 30430, /* A1 = -1.857300 */
9460 -32692, /* A2 = 0.997711 */
9461 21681, /* B2 = 0.661682 */
9462 -20082, /* B1 = -1.225708 */
9463 21681, /* B0 = 0.661682 */
9464 30526, /* A1 = -1.863220 */
9465 -32694, /* A2 = 0.997742 */
9466 1559, /* B2 = 0.047600 */
9467 -1459, /* B1 = -0.089096 */
9468 1559, /* B0 = 0.047600 */
9469 5, /* Internal filter scaling */
9470 159, /* Minimum in-band energy threshold */
9471 21, /* 21/32 in-band to broad-band ratio */
9472 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9473 },
9474 { /* f480_620[] */
9475 28975, /* A1 = 1.768494 */
9476 -30955, /* A2 = -0.944672 */
9477 -1026, /* B2 = -0.03133 */
9478 0, /* B1 = 0 */
9479 1026, /* B0 = 0.03133 */
9480 28613, /* A1 = 1.746399 */
9481 -32089, /* A2 = -0.979309 */
9482 14214, /* B2 = 0.433807 */
9483 -12202, /* B1 = -0.744812 */
9484 14214, /* B0 = 0.433807 */
9485 30243, /* A1 = 1.845947 */
9486 -32238, /* A2 = -0.983856 */
9487 24825, /* B2 = 0.757629 */
9488 -23402, /* B1 = -1.428345 */
9489 24825, /* B0 = 0.757629 */
9490 7, /* Internal filter scaling */
9491 159, /* Minimum in-band energy threshold */
9492 21, /* 21/32 in-band to broad-band ratio */
9493 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9494 },
9495 { /* f494 */
9496 30257, /* A1 = -1.846741 */
9497 -32605, /* A2 = 0.995056 */
9498 -249, /* B2 = -0.007625 */
9499 0, /* B1 = 0.000000 */
9500 249, /* B0 = 0.007625 */
9501 30247, /* A1 = -1.846191 */
9502 -32694, /* A2 = 0.997772 */
9503 18088, /* B2 = 0.552002 */
9504 -16652, /* B1 = -1.016418 */
9505 18088, /* B0 = 0.552002 */
9506 30348, /* A1 = -1.852295 */
9507 -32696, /* A2 = 0.997803 */
9508 2099, /* B2 = 0.064064 */
9509 -1953, /* B1 = -0.119202 */
9510 2099, /* B0 = 0.064064 */
9511 5, /* Internal filter scaling */
9512 159, /* Minimum in-band energy threshold */
9513 21, /* 21/32 in-band to broad-band ratio */
9514 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9515 },
9516 { /* f500 */
9517 30202, /* A1 = -1.843431 */
9518 -32624, /* A2 = 0.995622 */
9519 -413, /* B2 = -0.012622 */
9520 0, /* B1 = 0.000000 */
9521 413, /* B0 = 0.012622 */
9522 30191, /* A1 = -1.842721 */
9523 -32714, /* A2 = 0.998364 */
9524 25954, /* B2 = 0.792057 */
9525 -23890, /* B1 = -1.458131 */
9526 25954, /* B0 = 0.792057 */
9527 30296, /* A1 = -1.849172 */
9528 -32715, /* A2 = 0.998397 */
9529 2007, /* B2 = 0.061264 */
9530 -1860, /* B1 = -0.113568 */
9531 2007, /* B0 = 0.061264 */
9532 5, /* Internal filter scaling */
9533 159, /* Minimum in-band energy threshold */
9534 21, /* 21/32 in-band to broad-band ratio */
9535 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9536 },
9537 { /* f520 */
9538 30001, /* A1 = -1.831116 */
9539 -32613, /* A2 = 0.995270 */
9540 -155, /* B2 = -0.004750 */
9541 0, /* B1 = 0.000000 */
9542 155, /* B0 = 0.004750 */
9543 29985, /* A1 = -1.830200 */
9544 -32710, /* A2 = 0.998260 */
9545 6584, /* B2 = 0.200928 */
9546 -6018, /* B1 = -0.367355 */
9547 6584, /* B0 = 0.200928 */
9548 30105, /* A1 = -1.837524 */
9549 -32712, /* A2 = 0.998291 */
9550 23812, /* B2 = 0.726685 */
9551 -21936, /* B1 = -1.338928 */
9552 23812, /* B0 = 0.726685 */
9553 5, /* Internal filter scaling */
9554 159, /* Minimum in-band energy threshold */
9555 21, /* 21/32 in-band to broad-band ratio */
9556 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9557 },
9558 { /* f523 */
9559 29964, /* A1 = -1.828918 */
9560 -32601, /* A2 = 0.994904 */
9561 -101, /* B2 = -0.003110 */
9562 0, /* B1 = 0.000000 */
9563 101, /* B0 = 0.003110 */
9564 29949, /* A1 = -1.827942 */
9565 -32700, /* A2 = 0.997925 */
9566 11041, /* B2 = 0.336975 */
9567 -10075, /* B1 = -0.614960 */
9568 11041, /* B0 = 0.336975 */
9569 30070, /* A1 = -1.835388 */
9570 -32702, /* A2 = 0.997986 */
9571 16762, /* B2 = 0.511536 */
9572 -15437, /* B1 = -0.942230 */
9573 16762, /* B0 = 0.511536 */
9574 5, /* Internal filter scaling */
9575 159, /* Minimum in-band energy threshold */
9576 21, /* 21/32 in-band to broad-band ratio */
9577 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9578 },
9579 { /* f525 */
9580 29936, /* A1 = -1.827209 */
9581 -32584, /* A2 = 0.994415 */
9582 -91, /* B2 = -0.002806 */
9583 0, /* B1 = 0.000000 */
9584 91, /* B0 = 0.002806 */
9585 29921, /* A1 = -1.826233 */
9586 -32688, /* A2 = 0.997559 */
9587 11449, /* B2 = 0.349396 */
9588 -10426, /* B1 = -0.636383 */
9589 11449, /* B0 = 0.349396 */
9590 30045, /* A1 = -1.833862 */
9591 -32688, /* A2 = 0.997589 */
9592 13055, /* B2 = 0.398407 */
9593 -12028, /* B1 = -0.734161 */
9594 13055, /* B0 = 0.398407 */
9595 5, /* Internal filter scaling */
9596 159, /* Minimum in-band energy threshold */
9597 21, /* 21/32 in-band to broad-band ratio */
9598 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9599 },
9600 { /* f540_660[] */
9601 28499, /* A1 = 1.739441 */
9602 -31129, /* A2 = -0.949982 */
9603 -849, /* B2 = -0.025922 */
9604 0, /* B1 = 0 */
9605 849, /* B0 = 0.025922 */
9606 28128, /* A1 = 1.716797 */
9607 -32130, /* A2 = -0.98056 */
9608 14556, /* B2 = 0.444214 */
9609 -12251, /* B1 = -0.747772 */
9610 14556, /* B0 = 0.444244 */
9611 29667, /* A1 = 1.81073 */
9612 -32244, /* A2 = -0.984039 */
9613 23038, /* B2 = 0.703064 */
9614 -21358, /* B1 = -1.303589 */
9615 23040, /* B0 = 0.703125 */
9616 7, /* Internal filter scaling */
9617 159, /* Minimum in-band energy threshold */
9618 21, /* 21/32 in-band to broad-band ratio */
9619 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9620 },
9621 { /* f587 */
9622 29271, /* A1 = -1.786560 */
9623 -32599, /* A2 = 0.994873 */
9624 -490, /* B2 = -0.014957 */
9625 0, /* B1 = 0.000000 */
9626 490, /* B0 = 0.014957 */
9627 29246, /* A1 = -1.785095 */
9628 -32700, /* A2 = 0.997925 */
9629 28961, /* B2 = 0.883850 */
9630 -25796, /* B1 = -1.574463 */
9631 28961, /* B0 = 0.883850 */
9632 29383, /* A1 = -1.793396 */
9633 -32700, /* A2 = 0.997955 */
9634 1299, /* B2 = 0.039650 */
9635 -1169, /* B1 = -0.071396 */
9636 1299, /* B0 = 0.039650 */
9637 5, /* Internal filter scaling */
9638 159, /* Minimum in-band energy threshold */
9639 21, /* 21/32 in-band to broad-band ratio */
9640 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9641 },
9642 { /* f590 */
9643 29230, /* A1 = -1.784058 */
9644 -32584, /* A2 = 0.994415 */
9645 -418, /* B2 = -0.012757 */
9646 0, /* B1 = 0.000000 */
9647 418, /* B0 = 0.012757 */
9648 29206, /* A1 = -1.782593 */
9649 -32688, /* A2 = 0.997559 */
9650 36556, /* B2 = 1.115601 */
9651 -32478, /* B1 = -1.982300 */
9652 36556, /* B0 = 1.115601 */
9653 29345, /* A1 = -1.791077 */
9654 -32688, /* A2 = 0.997589 */
9655 897, /* B2 = 0.027397 */
9656 -808, /* B1 = -0.049334 */
9657 897, /* B0 = 0.027397 */
9658 5, /* Internal filter scaling */
9659 159, /* Minimum in-band energy threshold */
9660 21, /* 21/32 in-band to broad-band ratio */
9661 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9662 },
9663 { /* f600 */
9664 29116, /* A1 = -1.777100 */
9665 -32603, /* A2 = 0.994965 */
9666 -165, /* B2 = -0.005039 */
9667 0, /* B1 = 0.000000 */
9668 165, /* B0 = 0.005039 */
9669 29089, /* A1 = -1.775452 */
9670 -32708, /* A2 = 0.998199 */
9671 6963, /* B2 = 0.212494 */
9672 -6172, /* B1 = -0.376770 */
9673 6963, /* B0 = 0.212494 */
9674 29237, /* A1 = -1.784485 */
9675 -32710, /* A2 = 0.998230 */
9676 24197, /* B2 = 0.738464 */
9677 -21657, /* B1 = -1.321899 */
9678 24197, /* B0 = 0.738464 */
9679 5, /* Internal filter scaling */
9680 159, /* Minimum in-band energy threshold */
9681 21, /* 21/32 in-band to broad-band ratio */
9682 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9683 },
9684 { /* f660 */
9685 28376, /* A1 = -1.731934 */
9686 -32567, /* A2 = 0.993896 */
9687 -363, /* B2 = -0.011102 */
9688 0, /* B1 = 0.000000 */
9689 363, /* B0 = 0.011102 */
9690 28337, /* A1 = -1.729614 */
9691 -32683, /* A2 = 0.997434 */
9692 21766, /* B2 = 0.664246 */
9693 -18761, /* B1 = -1.145081 */
9694 21766, /* B0 = 0.664246 */
9695 28513, /* A1 = -1.740356 */
9696 -32686, /* A2 = 0.997498 */
9697 2509, /* B2 = 0.076584 */
9698 -2196, /* B1 = -0.134041 */
9699 2509, /* B0 = 0.076584 */
9700 5, /* Internal filter scaling */
9701 159, /* Minimum in-band energy threshold */
9702 21, /* 21/32 in-band to broad-band ratio */
9703 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9704 },
9705 { /* f700 */
9706 27844, /* A1 = -1.699463 */
9707 -32563, /* A2 = 0.993744 */
9708 -366, /* B2 = -0.011187 */
9709 0, /* B1 = 0.000000 */
9710 366, /* B0 = 0.011187 */
9711 27797, /* A1 = -1.696655 */
9712 -32686, /* A2 = 0.997498 */
9713 22748, /* B2 = 0.694214 */
9714 -19235, /* B1 = -1.174072 */
9715 22748, /* B0 = 0.694214 */
9716 27995, /* A1 = -1.708740 */
9717 -32688, /* A2 = 0.997559 */
9718 2964, /* B2 = 0.090477 */
9719 -2546, /* B1 = -0.155449 */
9720 2964, /* B0 = 0.090477 */
9721 5, /* Internal filter scaling */
9722 159, /* Minimum in-band energy threshold */
9723 21, /* 21/32 in-band to broad-band ratio */
9724 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9725 },
9726 { /* f740 */
9727 27297, /* A1 = -1.666077 */
9728 -32551, /* A2 = 0.993408 */
9729 -345, /* B2 = -0.010540 */
9730 0, /* B1 = 0.000000 */
9731 345, /* B0 = 0.010540 */
9732 27240, /* A1 = -1.662598 */
9733 -32683, /* A2 = 0.997406 */
9734 22560, /* B2 = 0.688477 */
9735 -18688, /* B1 = -1.140625 */
9736 22560, /* B0 = 0.688477 */
9737 27461, /* A1 = -1.676147 */
9738 -32684, /* A2 = 0.997467 */
9739 3541, /* B2 = 0.108086 */
9740 -2985, /* B1 = -0.182220 */
9741 3541, /* B0 = 0.108086 */
9742 5, /* Internal filter scaling */
9743 159, /* Minimum in-band energy threshold */
9744 21, /* 21/32 in-band to broad-band ratio */
9745 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9746 },
9747 { /* f750 */
9748 27155, /* A1 = -1.657410 */
9749 -32551, /* A2 = 0.993408 */
9750 -462, /* B2 = -0.014117 */
9751 0, /* B1 = 0.000000 */
9752 462, /* B0 = 0.014117 */
9753 27097, /* A1 = -1.653870 */
9754 -32683, /* A2 = 0.997406 */
9755 32495, /* B2 = 0.991699 */
9756 -26776, /* B1 = -1.634338 */
9757 32495, /* B0 = 0.991699 */
9758 27321, /* A1 = -1.667542 */
9759 -32684, /* A2 = 0.997467 */
9760 1835, /* B2 = 0.056007 */
9761 -1539, /* B1 = -0.093948 */
9762 1835, /* B0 = 0.056007 */
9763 5, /* Internal filter scaling */
9764 159, /* Minimum in-band energy threshold */
9765 21, /* 21/32 in-band to broad-band ratio */
9766 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9767 },
9768 { /* f750_1450[] */
9769 19298, /* A1 = 1.177917 */
9770 -24471, /* A2 = -0.746796 */
9771 -4152, /* B2 = -0.126709 */
9772 0, /* B1 = 0 */
9773 4152, /* B0 = 0.126709 */
9774 12902, /* A1 = 0.787476 */
9775 -29091, /* A2 = -0.887817 */
9776 12491, /* B2 = 0.38121 */
9777 -1794, /* B1 = -0.109528 */
9778 12494, /* B0 = 0.381317 */
9779 26291, /* A1 = 1.604736 */
9780 -30470, /* A2 = -0.929901 */
9781 28859, /* B2 = 0.880737 */
9782 -26084, /* B1 = -1.592102 */
9783 28861, /* B0 = 0.880798 */
9784 7, /* Internal filter scaling */
9785 159, /* Minimum in-band energy threshold */
9786 21, /* 21/32 in-band to broad-band ratio */
9787 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9788 },
9789 { /* f770 */
9790 26867, /* A1 = -1.639832 */
9791 -32551, /* A2 = 0.993408 */
9792 -123, /* B2 = -0.003755 */
9793 0, /* B1 = 0.000000 */
9794 123, /* B0 = 0.003755 */
9795 26805, /* A1 = -1.636108 */
9796 -32683, /* A2 = 0.997406 */
9797 17297, /* B2 = 0.527863 */
9798 -14096, /* B1 = -0.860382 */
9799 17297, /* B0 = 0.527863 */
9800 27034, /* A1 = -1.650085 */
9801 -32684, /* A2 = 0.997467 */
9802 12958, /* B2 = 0.395477 */
9803 -10756, /* B1 = -0.656525 */
9804 12958, /* B0 = 0.395477 */
9805 5, /* Internal filter scaling */
9806 159, /* Minimum in-band energy threshold */
9807 21, /* 21/32 in-band to broad-band ratio */
9808 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9809 },
9810 { /* f800 */
9811 26413, /* A1 = -1.612122 */
9812 -32547, /* A2 = 0.993286 */
9813 -223, /* B2 = -0.006825 */
9814 0, /* B1 = 0.000000 */
9815 223, /* B0 = 0.006825 */
9816 26342, /* A1 = -1.607849 */
9817 -32686, /* A2 = 0.997498 */
9818 6391, /* B2 = 0.195053 */
9819 -5120, /* B1 = -0.312531 */
9820 6391, /* B0 = 0.195053 */
9821 26593, /* A1 = -1.623108 */
9822 -32688, /* A2 = 0.997559 */
9823 23681, /* B2 = 0.722717 */
9824 -19328, /* B1 = -1.179688 */
9825 23681, /* B0 = 0.722717 */
9826 5, /* Internal filter scaling */
9827 159, /* Minimum in-band energy threshold */
9828 21, /* 21/32 in-band to broad-band ratio */
9829 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9830 },
9831 { /* f816 */
9832 26168, /* A1 = -1.597209 */
9833 -32528, /* A2 = 0.992706 */
9834 -235, /* B2 = -0.007182 */
9835 0, /* B1 = 0.000000 */
9836 235, /* B0 = 0.007182 */
9837 26092, /* A1 = -1.592590 */
9838 -32675, /* A2 = 0.997192 */
9839 20823, /* B2 = 0.635498 */
9840 -16510, /* B1 = -1.007751 */
9841 20823, /* B0 = 0.635498 */
9842 26363, /* A1 = -1.609070 */
9843 -32677, /* A2 = 0.997253 */
9844 6739, /* B2 = 0.205688 */
9845 -5459, /* B1 = -0.333206 */
9846 6739, /* B0 = 0.205688 */
9847 5, /* Internal filter scaling */
9848 159, /* Minimum in-band energy threshold */
9849 21, /* 21/32 in-band to broad-band ratio */
9850 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9851 },
9852 { /* f850 */
9853 25641, /* A1 = -1.565063 */
9854 -32536, /* A2 = 0.992950 */
9855 -121, /* B2 = -0.003707 */
9856 0, /* B1 = 0.000000 */
9857 121, /* B0 = 0.003707 */
9858 25560, /* A1 = -1.560059 */
9859 -32684, /* A2 = 0.997437 */
9860 18341, /* B2 = 0.559753 */
9861 -14252, /* B1 = -0.869904 */
9862 18341, /* B0 = 0.559753 */
9863 25837, /* A1 = -1.577026 */
9864 -32684, /* A2 = 0.997467 */
9865 16679, /* B2 = 0.509003 */
9866 -13232, /* B1 = -0.807648 */
9867 16679, /* B0 = 0.509003 */
9868 5, /* Internal filter scaling */
9869 159, /* Minimum in-band energy threshold */
9870 21, /* 21/32 in-band to broad-band ratio */
9871 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9872 },
9873 { /* f857_1645[] */
9874 16415, /* A1 = 1.001953 */
9875 -23669, /* A2 = -0.722321 */
9876 -4549, /* B2 = -0.138847 */
9877 0, /* B1 = 0 */
9878 4549, /* B0 = 0.138847 */
9879 8456, /* A1 = 0.516174 */
9880 -28996, /* A2 = -0.884918 */
9881 13753, /* B2 = 0.419724 */
9882 -12, /* B1 = -0.000763 */
9883 13757, /* B0 = 0.419846 */
9884 24632, /* A1 = 1.503418 */
9885 -30271, /* A2 = -0.923828 */
9886 29070, /* B2 = 0.887146 */
9887 -25265, /* B1 = -1.542114 */
9888 29073, /* B0 = 0.887268 */
9889 7, /* Internal filter scaling */
9890 159, /* Minimum in-band energy threshold */
9891 21, /* 21/32 in-band to broad-band ratio */
9892 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9893 },
9894 { /* f900 */
9895 24806, /* A1 = -1.514099 */
9896 -32501, /* A2 = 0.991852 */
9897 -326, /* B2 = -0.009969 */
9898 0, /* B1 = 0.000000 */
9899 326, /* B0 = 0.009969 */
9900 24709, /* A1 = -1.508118 */
9901 -32659, /* A2 = 0.996674 */
9902 20277, /* B2 = 0.618835 */
9903 -15182, /* B1 = -0.926636 */
9904 20277, /* B0 = 0.618835 */
9905 25022, /* A1 = -1.527222 */
9906 -32661, /* A2 = 0.996735 */
9907 4320, /* B2 = 0.131836 */
9908 -3331, /* B1 = -0.203339 */
9909 4320, /* B0 = 0.131836 */
9910 5, /* Internal filter scaling */
9911 159, /* Minimum in-band energy threshold */
9912 21, /* 21/32 in-band to broad-band ratio */
9913 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9914 },
9915 { /* f900_1300[] */
9916 19776, /* A1 = 1.207092 */
9917 -27437, /* A2 = -0.837341 */
9918 -2666, /* B2 = -0.081371 */
9919 0, /* B1 = 0 */
9920 2666, /* B0 = 0.081371 */
9921 16302, /* A1 = 0.995026 */
9922 -30354, /* A2 = -0.926361 */
9923 10389, /* B2 = 0.317062 */
9924 -3327, /* B1 = -0.203064 */
9925 10389, /* B0 = 0.317062 */
9926 24299, /* A1 = 1.483154 */
9927 -30930, /* A2 = -0.943909 */
9928 25016, /* B2 = 0.763428 */
9929 -21171, /* B1 = -1.292236 */
9930 25016, /* B0 = 0.763428 */
9931 7, /* Internal filter scaling */
9932 159, /* Minimum in-band energy threshold */
9933 21, /* 21/32 in-band to broad-band ratio */
9934 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9935 },
9936 { /* f935_1215[] */
9937 20554, /* A1 = 1.254517 */
9938 -28764, /* A2 = -0.877838 */
9939 -2048, /* B2 = -0.062515 */
9940 0, /* B1 = 0 */
9941 2048, /* B0 = 0.062515 */
9942 18209, /* A1 = 1.11145 */
9943 -30951, /* A2 = -0.94458 */
9944 9390, /* B2 = 0.286575 */
9945 -3955, /* B1 = -0.241455 */
9946 9390, /* B0 = 0.286575 */
9947 23902, /* A1 = 1.458923 */
9948 -31286, /* A2 = -0.954803 */
9949 23252, /* B2 = 0.709595 */
9950 -19132, /* B1 = -1.167725 */
9951 23252, /* B0 = 0.709595 */
9952 7, /* Internal filter scaling */
9953 159, /* Minimum in-band energy threshold */
9954 21, /* 21/32 in-band to broad-band ratio */
9955 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9956 },
9957 { /* f941_1477[] */
9958 17543, /* A1 = 1.07074 */
9959 -26220, /* A2 = -0.800201 */
9960 -3298, /* B2 = -0.100647 */
9961 0, /* B1 = 0 */
9962 3298, /* B0 = 0.100647 */
9963 12423, /* A1 = 0.75827 */
9964 -30036, /* A2 = -0.916626 */
9965 12651, /* B2 = 0.386078 */
9966 -2444, /* B1 = -0.14917 */
9967 12653, /* B0 = 0.386154 */
9968 23518, /* A1 = 1.435425 */
9969 -30745, /* A2 = -0.938293 */
9970 27282, /* B2 = 0.832581 */
9971 -22529, /* B1 = -1.375122 */
9972 27286, /* B0 = 0.832703 */
9973 7, /* Internal filter scaling */
9974 159, /* Minimum in-band energy threshold */
9975 21, /* 21/32 in-band to broad-band ratio */
9976 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9977 },
9978 { /* f942 */
9979 24104, /* A1 = -1.471252 */
9980 -32507, /* A2 = 0.992065 */
9981 -351, /* B2 = -0.010722 */
9982 0, /* B1 = 0.000000 */
9983 351, /* B0 = 0.010722 */
9984 23996, /* A1 = -1.464600 */
9985 -32671, /* A2 = 0.997040 */
9986 22848, /* B2 = 0.697266 */
9987 -16639, /* B1 = -1.015564 */
9988 22848, /* B0 = 0.697266 */
9989 24332, /* A1 = -1.485168 */
9990 -32673, /* A2 = 0.997101 */
9991 4906, /* B2 = 0.149727 */
9992 -3672, /* B1 = -0.224174 */
9993 4906, /* B0 = 0.149727 */
9994 5, /* Internal filter scaling */
9995 159, /* Minimum in-band energy threshold */
9996 21, /* 21/32 in-band to broad-band ratio */
9997 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9998 },
9999 { /* f950 */
10000 23967, /* A1 = -1.462830 */
10001 -32507, /* A2 = 0.992065 */
10002 -518, /* B2 = -0.015821 */
10003 0, /* B1 = 0.000000 */
10004 518, /* B0 = 0.015821 */
10005 23856, /* A1 = -1.456055 */
10006 -32671, /* A2 = 0.997040 */
10007 26287, /* B2 = 0.802246 */
10008 -19031, /* B1 = -1.161560 */
10009 26287, /* B0 = 0.802246 */
10010 24195, /* A1 = -1.476746 */
10011 -32673, /* A2 = 0.997101 */
10012 2890, /* B2 = 0.088196 */
10013 -2151, /* B1 = -0.131317 */
10014 2890, /* B0 = 0.088196 */
10015 5, /* Internal filter scaling */
10016 159, /* Minimum in-band energy threshold */
10017 21, /* 21/32 in-band to broad-band ratio */
10018 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10019 },
10020 { /* f950_1400[] */
10021 18294, /* A1 = 1.116638 */
10022 -26962, /* A2 = -0.822845 */
10023 -2914, /* B2 = -0.088936 */
10024 0, /* B1 = 0 */
10025 2914, /* B0 = 0.088936 */
10026 14119, /* A1 = 0.861786 */
10027 -30227, /* A2 = -0.922455 */
10028 11466, /* B2 = 0.349945 */
10029 -2833, /* B1 = -0.172943 */
10030 11466, /* B0 = 0.349945 */
10031 23431, /* A1 = 1.430115 */
10032 -30828, /* A2 = -0.940796 */
10033 25331, /* B2 = 0.773071 */
10034 -20911, /* B1 = -1.276367 */
10035 25331, /* B0 = 0.773071 */
10036 7, /* Internal filter scaling */
10037 159, /* Minimum in-band energy threshold */
10038 21, /* 21/32 in-band to broad-band ratio */
10039 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10040 },
10041 { /* f975 */
10042 23521, /* A1 = -1.435608 */
10043 -32489, /* A2 = 0.991516 */
10044 -193, /* B2 = -0.005915 */
10045 0, /* B1 = 0.000000 */
10046 193, /* B0 = 0.005915 */
10047 23404, /* A1 = -1.428467 */
10048 -32655, /* A2 = 0.996582 */
10049 17740, /* B2 = 0.541412 */
10050 -12567, /* B1 = -0.767029 */
10051 17740, /* B0 = 0.541412 */
10052 23753, /* A1 = -1.449829 */
10053 -32657, /* A2 = 0.996613 */
10054 9090, /* B2 = 0.277405 */
10055 -6662, /* B1 = -0.406647 */
10056 9090, /* B0 = 0.277405 */
10057 5, /* Internal filter scaling */
10058 159, /* Minimum in-band energy threshold */
10059 21, /* 21/32 in-band to broad-band ratio */
10060 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10061 },
10062 { /* f1000 */
10063 23071, /* A1 = -1.408203 */
10064 -32489, /* A2 = 0.991516 */
10065 -293, /* B2 = -0.008965 */
10066 0, /* B1 = 0.000000 */
10067 293, /* B0 = 0.008965 */
10068 22951, /* A1 = -1.400818 */
10069 -32655, /* A2 = 0.996582 */
10070 5689, /* B2 = 0.173645 */
10071 -3951, /* B1 = -0.241150 */
10072 5689, /* B0 = 0.173645 */
10073 23307, /* A1 = -1.422607 */
10074 -32657, /* A2 = 0.996613 */
10075 18692, /* B2 = 0.570435 */
10076 -13447, /* B1 = -0.820770 */
10077 18692, /* B0 = 0.570435 */
10078 5, /* Internal filter scaling */
10079 159, /* Minimum in-band energy threshold */
10080 21, /* 21/32 in-band to broad-band ratio */
10081 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10082 },
10083 { /* f1020 */
10084 22701, /* A1 = -1.385620 */
10085 -32474, /* A2 = 0.991058 */
10086 -292, /* B2 = -0.008933 */
10087 0, /*163840 , B1 = 10.000000 */
10088 292, /* B0 = 0.008933 */
10089 22564, /* A1 = -1.377258 */
10090 -32655, /* A2 = 0.996552 */
10091 20756, /* B2 = 0.633423 */
10092 -14176, /* B1 = -0.865295 */
10093 20756, /* B0 = 0.633423 */
10094 22960, /* A1 = -1.401428 */
10095 -32657, /* A2 = 0.996613 */
10096 6520, /* B2 = 0.198990 */
10097 -4619, /* B1 = -0.281937 */
10098 6520, /* B0 = 0.198990 */
10099 5, /* Internal filter scaling */
10100 159, /* Minimum in-band energy threshold */
10101 21, /* 21/32 in-band to broad-band ratio */
10102 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10103 },
10104 { /* f1050 */
10105 22142, /* A1 = -1.351501 */
10106 -32474, /* A2 = 0.991058 */
10107 -147, /* B2 = -0.004493 */
10108 0, /* B1 = 0.000000 */
10109 147, /* B0 = 0.004493 */
10110 22000, /* A1 = -1.342834 */
10111 -32655, /* A2 = 0.996552 */
10112 15379, /* B2 = 0.469360 */
10113 -10237, /* B1 = -0.624847 */
10114 15379, /* B0 = 0.469360 */
10115 22406, /* A1 = -1.367554 */
10116 -32657, /* A2 = 0.996613 */
10117 17491, /* B2 = 0.533783 */
10118 -12096, /* B1 = -0.738312 */
10119 17491, /* B0 = 0.533783 */
10120 5, /* Internal filter scaling */
10121 159, /* Minimum in-band energy threshold */
10122 21, /* 21/32 in-band to broad-band ratio */
10123 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10124 },
10125 { /* f1100_1750[] */
10126 12973, /* A1 = 0.79184 */
10127 -24916, /* A2 = -0.760376 */
10128 6655, /* B2 = 0.203102 */
10129 367, /* B1 = 0.0224 */
10130 6657, /* B0 = 0.203171 */
10131 5915, /* A1 = 0.361053 */
10132 -29560, /* A2 = -0.90213 */
10133 -7777, /* B2 = -0.23735 */
10134 0, /* B1 = 0 */
10135 7777, /* B0 = 0.23735 */
10136 20510, /* A1 = 1.251892 */
10137 -30260, /* A2 = -0.923462 */
10138 26662, /* B2 = 0.81366 */
10139 -20573, /* B1 = -1.255737 */
10140 26668, /* B0 = 0.813843 */
10141 7, /* Internal filter scaling */
10142 159, /* Minimum in-band energy threshold */
10143 21, /* 21/32 in-band to broad-band ratio */
10144 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10145 },
10146 { /* f1140 */
10147 20392, /* A1 = -1.244629 */
10148 -32460, /* A2 = 0.990601 */
10149 -270, /* B2 = -0.008240 */
10150 0, /* B1 = 0.000000 */
10151 270, /* B0 = 0.008240 */
10152 20218, /* A1 = -1.234009 */
10153 -32655, /* A2 = 0.996582 */
10154 21337, /* B2 = 0.651154 */
10155 -13044, /* B1 = -0.796143 */
10156 21337, /* B0 = 0.651154 */
10157 20684, /* A1 = -1.262512 */
10158 -32657, /* A2 = 0.996643 */
10159 8572, /* B2 = 0.261612 */
10160 -5476, /* B1 = -0.334244 */
10161 8572, /* B0 = 0.261612 */
10162 5, /* Internal filter scaling */
10163 159, /* Minimum in-band energy threshold */
10164 21, /* 21/32 in-band to broad-band ratio */
10165 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10166 },
10167 { /* f1200 */
10168 19159, /* A1 = -1.169373 */
10169 -32456, /* A2 = 0.990509 */
10170 -335, /* B2 = -0.010252 */
10171 0, /* B1 = 0.000000 */
10172 335, /* B0 = 0.010252 */
10173 18966, /* A1 = -1.157593 */
10174 -32661, /* A2 = 0.996735 */
10175 6802, /* B2 = 0.207588 */
10176 -3900, /* B1 = -0.238098 */
10177 6802, /* B0 = 0.207588 */
10178 19467, /* A1 = -1.188232 */
10179 -32661, /* A2 = 0.996765 */
10180 25035, /* B2 = 0.764008 */
10181 -15049, /* B1 = -0.918579 */
10182 25035, /* B0 = 0.764008 */
10183 5, /* Internal filter scaling */
10184 159, /* Minimum in-band energy threshold */
10185 21, /* 21/32 in-band to broad-band ratio */
10186 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10187 },
10188 { /* f1209 */
10189 18976, /* A1 = -1.158264 */
10190 -32439, /* A2 = 0.989990 */
10191 -183, /* B2 = -0.005588 */
10192 0, /* B1 = 0.000000 */
10193 183, /* B0 = 0.005588 */
10194 18774, /* A1 = -1.145874 */
10195 -32650, /* A2 = 0.996429 */
10196 15468, /* B2 = 0.472076 */
10197 -8768, /* B1 = -0.535217 */
10198 15468, /* B0 = 0.472076 */
10199 19300, /* A1 = -1.177979 */
10200 -32652, /* A2 = 0.996490 */
10201 19840, /* B2 = 0.605499 */
10202 -11842, /* B1 = -0.722809 */
10203 19840, /* B0 = 0.605499 */
10204 5, /* Internal filter scaling */
10205 159, /* Minimum in-band energy threshold */
10206 21, /* 21/32 in-band to broad-band ratio */
10207 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10208 },
10209 { /* f1330 */
10210 16357, /* A1 = -0.998413 */
10211 -32368, /* A2 = 0.987793 */
10212 -217, /* B2 = -0.006652 */
10213 0, /* B1 = 0.000000 */
10214 217, /* B0 = 0.006652 */
10215 16107, /* A1 = -0.983126 */
10216 -32601, /* A2 = 0.994904 */
10217 11602, /* B2 = 0.354065 */
10218 -5555, /* B1 = -0.339111 */
10219 11602, /* B0 = 0.354065 */
10220 16722, /* A1 = -1.020630 */
10221 -32603, /* A2 = 0.994965 */
10222 15574, /* B2 = 0.475311 */
10223 -8176, /* B1 = -0.499069 */
10224 15574, /* B0 = 0.475311 */
10225 5, /* Internal filter scaling */
10226 159, /* Minimum in-band energy threshold */
10227 21, /* 21/32 in-band to broad-band ratio */
10228 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10229 },
10230 { /* f1336 */
10231 16234, /* A1 = -0.990875 */
10232 32404, /* A2 = -0.988922 */
10233 -193, /* B2 = -0.005908 */
10234 0, /* B1 = 0.000000 */
10235 193, /* B0 = 0.005908 */
10236 15986, /* A1 = -0.975769 */
10237 -32632, /* A2 = 0.995880 */
10238 18051, /* B2 = 0.550903 */
10239 -8658, /* B1 = -0.528473 */
10240 18051, /* B0 = 0.550903 */
10241 16591, /* A1 = -1.012695 */
10242 -32634, /* A2 = 0.995941 */
10243 15736, /* B2 = 0.480240 */
10244 -8125, /* B1 = -0.495926 */
10245 15736, /* B0 = 0.480240 */
10246 5, /* Internal filter scaling */
10247 159, /* Minimum in-band energy threshold */
10248 21, /* 21/32 in-band to broad-band ratio */
10249 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10250 },
10251 { /* f1366 */
10252 15564, /* A1 = -0.949982 */
10253 -32404, /* A2 = 0.988922 */
10254 -269, /* B2 = -0.008216 */
10255 0, /* B1 = 0.000000 */
10256 269, /* B0 = 0.008216 */
10257 15310, /* A1 = -0.934479 */
10258 -32632, /* A2 = 0.995880 */
10259 10815, /* B2 = 0.330063 */
10260 -4962, /* B1 = -0.302887 */
10261 10815, /* B0 = 0.330063 */
10262 15924, /* A1 = -0.971924 */
10263 -32634, /* A2 = 0.995941 */
10264 18880, /* B2 = 0.576172 */
10265 -9364, /* B1 = -0.571594 */
10266 18880, /* B0 = 0.576172 */
10267 5, /* Internal filter scaling */
10268 159, /* Minimum in-band energy threshold */
10269 21, /* 21/32 in-band to broad-band ratio */
10270 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10271 },
10272 { /* f1380 */
10273 15247, /* A1 = -0.930603 */
10274 -32397, /* A2 = 0.988708 */
10275 -244, /* B2 = -0.007451 */
10276 0, /* B1 = 0.000000 */
10277 244, /* B0 = 0.007451 */
10278 14989, /* A1 = -0.914886 */
10279 -32627, /* A2 = 0.995697 */
10280 18961, /* B2 = 0.578644 */
10281 -8498, /* B1 = -0.518707 */
10282 18961, /* B0 = 0.578644 */
10283 15608, /* A1 = -0.952667 */
10284 -32628, /* A2 = 0.995758 */
10285 11145, /* B2 = 0.340134 */
10286 -5430, /* B1 = -0.331467 */
10287 11145, /* B0 = 0.340134 */
10288 5, /* Internal filter scaling */
10289 159, /* Minimum in-band energy threshold */
10290 21, /* 21/32 in-band to broad-band ratio */
10291 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10292 },
10293 { /* f1400 */
10294 14780, /* A1 = -0.902130 */
10295 -32393, /* A2 = 0.988586 */
10296 -396, /* B2 = -0.012086 */
10297 0, /* B1 = 0.000000 */
10298 396, /* B0 = 0.012086 */
10299 14510, /* A1 = -0.885651 */
10300 -32630, /* A2 = 0.995819 */
10301 6326, /* B2 = 0.193069 */
10302 -2747, /* B1 = -0.167671 */
10303 6326, /* B0 = 0.193069 */
10304 15154, /* A1 = -0.924957 */
10305 -32632, /* A2 = 0.995850 */
10306 23235, /* B2 = 0.709076 */
10307 -10983, /* B1 = -0.670380 */
10308 23235, /* B0 = 0.709076 */
10309 5, /* Internal filter scaling */
10310 159, /* Minimum in-band energy threshold */
10311 21, /* 21/32 in-band to broad-band ratio */
10312 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10313 },
10314 { /* f1477 */
10315 13005, /* A1 = -0.793793 */
10316 -32368, /* A2 = 0.987823 */
10317 -500, /* B2 = -0.015265 */
10318 0, /* B1 = 0.000000 */
10319 500, /* B0 = 0.015265 */
10320 12708, /* A1 = -0.775665 */
10321 -32615, /* A2 = 0.995331 */
10322 11420, /* B2 = 0.348526 */
10323 -4306, /* B1 = -0.262833 */
10324 11420, /* B0 = 0.348526 */
10325 13397, /* A1 = -0.817688 */
10326 -32615, /* A2 = 0.995361 */
10327 9454, /* B2 = 0.288528 */
10328 -3981, /* B1 = -0.243027 */
10329 9454, /* B0 = 0.288528 */
10330 5, /* Internal filter scaling */
10331 159, /* Minimum in-band energy threshold */
10332 21, /* 21/32 in-band to broad-band ratio */
10333 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10334 },
10335 { /* f1600 */
10336 10046, /* A1 = -0.613190 */
10337 -32331, /* A2 = 0.986694 */
10338 -455, /* B2 = -0.013915 */
10339 0, /* B1 = 0.000000 */
10340 455, /* B0 = 0.013915 */
10341 9694, /* A1 = -0.591705 */
10342 -32601, /* A2 = 0.994934 */
10343 6023, /* B2 = 0.183815 */
10344 -1708, /* B1 = -0.104279 */
10345 6023, /* B0 = 0.183815 */
10346 10478, /* A1 = -0.639587 */
10347 -32603, /* A2 = 0.994965 */
10348 22031, /* B2 = 0.672333 */
10349 -7342, /* B1 = -0.448151 */
10350 22031, /* B0 = 0.672333 */
10351 5, /* Internal filter scaling */
10352 159, /* Minimum in-band energy threshold */
10353 21, /* 21/32 in-band to broad-band ratio */
10354 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10355 },
10356 { /* f1633_1638[] */
10357 9181, /* A1 = 0.560394 */
10358 -32256, /* A2 = -0.984375 */
10359 -556, /* B2 = -0.016975 */
10360 0, /* B1 = 0 */
10361 556, /* B0 = 0.016975 */
10362 8757, /* A1 = 0.534515 */
10363 -32574, /* A2 = -0.99408 */
10364 8443, /* B2 = 0.25769 */
10365 -2135, /* B1 = -0.130341 */
10366 8443, /* B0 = 0.25769 */
10367 9691, /* A1 = 0.591522 */
10368 -32574, /* A2 = -0.99411 */
10369 15446, /* B2 = 0.471375 */
10370 -4809, /* B1 = -0.293579 */
10371 15446, /* B0 = 0.471375 */
10372 7, /* Internal filter scaling */
10373 159, /* Minimum in-band energy threshold */
10374 21, /* 21/32 in-band to broad-band ratio */
10375 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10376 },
10377 { /* f1800 */
10378 5076, /* A1 = -0.309875 */
10379 -32304, /* A2 = 0.985840 */
10380 -508, /* B2 = -0.015503 */
10381 0, /* B1 = 0.000000 */
10382 508, /* B0 = 0.015503 */
10383 4646, /* A1 = -0.283600 */
10384 -32605, /* A2 = 0.995026 */
10385 6742, /* B2 = 0.205780 */
10386 -878, /* B1 = -0.053635 */
10387 6742, /* B0 = 0.205780 */
10388 5552, /* A1 = -0.338928 */
10389 -32605, /* A2 = 0.995056 */
10390 23667, /* B2 = 0.722260 */
10391 -4297, /* B1 = -0.262329 */
10392 23667, /* B0 = 0.722260 */
10393 5, /* Internal filter scaling */
10394 159, /* Minimum in-band energy threshold */
10395 21, /* 21/32 in-band to broad-band ratio */
10396 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10397 },
10398 { /* f1860 */
10399 3569, /* A1 = -0.217865 */
10400 -32292, /* A2 = 0.985504 */
10401 -239, /* B2 = -0.007322 */
10402 0, /* B1 = 0.000000 */
10403 239, /* B0 = 0.007322 */
10404 3117, /* A1 = -0.190277 */
10405 -32603, /* A2 = 0.994965 */
10406 18658, /* B2 = 0.569427 */
10407 -1557, /* B1 = -0.095032 */
10408 18658, /* B0 = 0.569427 */
10409 4054, /* A1 = -0.247437 */
10410 -32603, /* A2 = 0.994965 */
10411 18886, /* B2 = 0.576385 */
10412 -2566, /* B1 = -0.156647 */
10413 18886, /* B0 = 0.576385 */
10414 5, /* Internal filter scaling */
10415 159, /* Minimum in-band energy threshold */
10416 21, /* 21/32 in-band to broad-band ratio */
10417 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10418 },
10419 };
10420 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10421 {
10422 unsigned short cmd;
10423 int cnt, max;
10424
10425 if (jf->filter > 3) {
10426 return -1;
10427 }
10428 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10429
10430 return -1;
10431 if (!jf->enable) {
10432 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10433
10434 return -1;
10435 else
10436 return 0;
10437 } else {
10438 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10439
10440 return -1;
10441 /* Select the filter (f0 - f3) to use. */
10442 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10443 return -1;
10444 }
10445 if (jf->freq < 12 && jf->freq > 3) {
10446 /* Select the frequency for the selected filter. */
10447 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10448 return -1;
10449 } else if (jf->freq > 11) {
10450 /* We need to load a programmable filter set for undefined */
10451 /* frequencies. So we will point the filter to a programmable set. */
10452 /* Since there are only 4 filters and 4 programmable sets, we will */
10453 /* just point the filter to the same number set and program it for the */
10454 /* frequency we want. */
10455 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10456 return -1;
10457 if (j->ver.low != 0x12) {
10458 cmd = 0x515B;
10459 max = 19;
10460 } else {
10461 cmd = 0x515E;
10462 max = 15;
10463 }
10464 if (ixj_WriteDSPCommand(cmd, j))
10465 return -1;
10466 for (cnt = 0; cnt < max; cnt++) {
10467 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10468 return -1;
10469 }
10470 }
10471 j->filter_en[jf->filter] = jf->enable;
10472 return 0;
10473 }
10474
10475 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10476 {
10477 unsigned short cmd;
10478 int cnt, max;
10479 if (jfr->filter > 3) {
10480 return -1;
10481 }
10482 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10483 return -1;
10484
10485 if (!jfr->enable) {
10486 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10487 return -1;
10488 else
10489 return 0;
10490 } else {
10491 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10492 return -1;
10493 /* Select the filter (f0 - f3) to use. */
10494 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10495 return -1;
10496 }
10497 /* We need to load a programmable filter set for undefined */
10498 /* frequencies. So we will point the filter to a programmable set. */
10499 /* Since there are only 4 filters and 4 programmable sets, we will */
10500 /* just point the filter to the same number set and program it for the */
10501 /* frequency we want. */
10502 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10503 return -1;
10504 if (j->ver.low != 0x12) {
10505 cmd = 0x515B;
10506 max = 19;
10507 } else {
10508 cmd = 0x515E;
10509 max = 15;
10510 }
10511 if (ixj_WriteDSPCommand(cmd, j))
10512 return -1;
10513 for (cnt = 0; cnt < max; cnt++) {
10514 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10515 return -1;
10516 }
10517 j->filter_en[jfr->filter] = jfr->enable;
10518 return 0;
10519 }
10520
10521 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10522 {
10523 int freq0, freq1;
10524 unsigned short data;
10525 if (ti->freq0) {
10526 freq0 = ti->freq0;
10527 } else {
10528 freq0 = 0x7FFF;
10529 }
10530
10531 if (ti->freq1) {
10532 freq1 = ti->freq1;
10533 } else {
10534 freq1 = 0x7FFF;
10535 }
10536
10537 if(ti->tone_index > 12 && ti->tone_index < 28)
10538 {
10539 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10540 return -1;
10541 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10542 return -1;
10543 data = freq0;
10544 if (ixj_WriteDSPCommand(data, j))
10545 return -1;
10546 data = freq1;
10547 if (ixj_WriteDSPCommand(data, j))
10548 return -1;
10549 }
10550 return freq0;
10551 }
10552
Linux with added FPC-III support