?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
proc: use seq_puts()/seq_putc() where possible
[linux-2.6/next.git] / drivers / telephony / ixj.c
blobc4bc8d5a9d18fd43ae3279c436ca23447848044c
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
46 * Audit some copy_*_user and minor cleanup.
47 *
48 * Revision 4.7 2001/08/13 06:19:33 craigs
49 * Added additional changes from Alan Cox and John Anderson for
50 * 2.2 to 2.4 cleanup and bounds checking
51 *
52 * Revision 4.6 2001/08/13 01:05:05 craigs
53 * Really fixed PHONE_QUERY_CODEC problem this time
54 *
55 * Revision 4.5 2001/08/13 00:11:03 craigs
56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57 *
58 * Revision 4.4 2001/08/07 07:58:12 craigs
59 * Changed back to three digit version numbers
60 * Added tagbuild target to allow automatic and easy tagging of versions
61 *
62 * Revision 4.3 2001/08/07 07:24:47 craigs
63 * Added ixj-ver.h to allow easy configuration management of driver
64 * Added display of version number in /prox/ixj
65 *
66 * Revision 4.2 2001/08/06 07:07:19 craigs
67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68 * behaviour of returning int rather than short *
69 *
70 * Revision 4.1 2001/08/05 00:17:37 craigs
71 * More changes for correct PCMCIA installation
72 * Start of changes for backward Linux compatibility
73 *
74 * Revision 4.0 2001/08/04 12:33:12 craigs
75 * New version using GNU autoconf
76 *
77 * Revision 3.105 2001/07/20 23:14:32 eokerson
78 * More work on CallerID generation when using ring cadences.
79 *
80 * Revision 3.104 2001/07/06 01:33:55 eokerson
81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
82 *
83 * Revision 3.103 2001/07/05 19:20:16 eokerson
84 * Updated HOWTO
85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86 *
87 * Revision 3.102 2001/07/03 23:51:21 eokerson
88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
89 *
90 * Revision 3.101 2001/07/02 19:26:56 eokerson
91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92 *
93 * Revision 3.100 2001/07/02 19:18:27 eokerson
94 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96 * Fixed speaker mode on Internet LineJACK.
97 *
98 * Revision 3.99 2001/05/09 14:11:16 eokerson
99 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
100 *
101 * Revision 3.98 2001/05/08 19:55:33 eokerson
102 * Fixed POTS hookstate detection while it is connected to PSTN port.
103 *
104 * Revision 3.97 2001/05/08 00:01:04 eokerson
105 * Fixed kernel oops when sending caller ID data.
106 *
107 * Revision 3.96 2001/05/04 23:09:30 eokerson
108 * Now uses one kernel timer for each card, instead of one for the entire driver.
109 *
110 * Revision 3.95 2001/04/25 22:06:47 eokerson
111 * Fixed squawking at beginning of some G.723.1 calls.
112 *
113 * Revision 3.94 2001/04/03 23:42:00 eokerson
114 * Added linear volume ioctls
115 * Added raw filter load ioctl
116 *
117 * Revision 3.93 2001/02/27 01:00:06 eokerson
118 * Fixed blocking in CallerID.
119 * Reduced size of ixj structure for smaller driver footprint.
120 *
121 * Revision 3.92 2001/02/20 22:02:59 eokerson
122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123 * Improved PSTN ring detection.
124 * Fixed wink generation on POTS ports.
125 *
126 * Revision 3.91 2001/02/13 00:55:44 eokerson
127 * Turn AEC back on after changing frame sizes.
128 *
129 * Revision 3.90 2001/02/12 16:42:00 eokerson
130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131 *
132 * Revision 3.89 2001/02/12 15:41:16 eokerson
133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
134 *
135 * Revision 3.88 2001/02/05 23:25:42 eokerson
136 * Fixed lockup bugs with deregister.
137 *
138 * Revision 3.87 2001/01/29 21:00:39 eokerson
139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
140 * Updated copyright date.
141 *
142 * Revision 3.86 2001/01/23 23:53:46 eokerson
143 * Fixes to G.729 compatibility.
144 *
145 * Revision 3.85 2001/01/23 21:30:36 eokerson
146 * Added verbage about cards supported.
147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148 *
149 * Revision 3.84 2001/01/22 23:32:10 eokerson
150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
151 *
152 * Revision 3.83 2001/01/19 14:51:41 eokerson
153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154 *
155 * Revision 3.82 2001/01/19 00:34:49 eokerson
156 * Added verbosity to write overlap errors.
157 *
158 * Revision 3.81 2001/01/18 23:56:54 eokerson
159 * Fixed PSTN line test functions.
160 *
161 * Revision 3.80 2001/01/18 22:29:27 eokerson
162 * Updated AEC/AGC values for different cards.
163 *
164 * Revision 3.79 2001/01/17 02:58:54 eokerson
165 * Fixed AEC reset after Caller ID.
166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167 *
168 * Revision 3.78 2001/01/16 19:43:09 eokerson
169 * Added support for Linux 2.4.x kernels.
170 *
171 * Revision 3.77 2001/01/09 04:00:52 eokerson
172 * Linetest will now test the line, even if it has previously succeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246 #include "ixj-ver.h"
247
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251
252 #include <linux/module.h>
253
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/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 succeded\n", j->board);
356 }
357 }
358 }
359 }
360
361 #else
362
363 static IXJ ixj[IXJMAX];
364 #define get_ixj(b) (&ixj[(b)])
365
366 /*
367 * Allocate a free IXJ device
368 */
369
370 static IXJ *ixj_alloc(void)
371 {
372 int cnt;
373 for(cnt=0; cnt<IXJMAX; cnt++) {
374 if(!ixj[cnt].DSPbase)
375 return &ixj[cnt];
376 }
377 return NULL;
378 }
379
380 static inline void ixj_fsk_free(IXJ *j) {;}
381
382 static inline void ixj_fsk_alloc(IXJ *j)
383 {
384 j->fsksize = 8000;
385 }
386
387 #endif
388
389 #ifdef PERFMON_STATS
390 #define ixj_perfmon(x) ((x)++)
391 #else
392 #define ixj_perfmon(x) do { } while(0)
393 #endif
394
395 static int ixj_convert_loaded;
396
397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
398
399 /************************************************************************
400 *
401 * These are function definitions to allow external modules to register
402 * enhanced functionality call backs.
403 *
404 ************************************************************************/
405
406 static int Stub(IXJ * J, unsigned long arg)
407 {
408 return 0;
409 }
410
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415
416 static void ixj_read_frame(IXJ *j);
417 static void ixj_write_frame(IXJ *j);
418 static void ixj_init_timer(IXJ *j);
419 static void ixj_add_timer(IXJ * j);
420 static void ixj_timeout(unsigned long ptr);
421 static int read_filters(IXJ *j);
422 static int LineMonitor(IXJ *j);
423 static int ixj_fasync(int fd, struct file *, int mode);
424 static int ixj_set_port(IXJ *j, int arg);
425 static int ixj_set_pots(IXJ *j, int arg);
426 static int ixj_hookstate(IXJ *j);
427 static int ixj_record_start(IXJ *j);
428 static void ixj_record_stop(IXJ *j);
429 static void set_rec_volume(IXJ *j, int volume);
430 static int get_rec_volume(IXJ *j);
431 static int set_rec_codec(IXJ *j, int rate);
432 static void ixj_vad(IXJ *j, int arg);
433 static int ixj_play_start(IXJ *j);
434 static void ixj_play_stop(IXJ *j);
435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
436 static int ixj_set_tone_off(unsigned short, IXJ *j);
437 static int ixj_play_tone(IXJ *j, char tone);
438 static void ixj_aec_start(IXJ *j, int level);
439 static int idle(IXJ *j);
440 static void ixj_ring_on(IXJ *j);
441 static void ixj_ring_off(IXJ *j);
442 static void aec_stop(IXJ *j);
443 static void ixj_ringback(IXJ *j);
444 static void ixj_busytone(IXJ *j);
445 static void ixj_dialtone(IXJ *j);
446 static void ixj_cpt_stop(IXJ *j);
447 static char daa_int_read(IXJ *j);
448 static char daa_CR_read(IXJ *j, int cr);
449 static int daa_set_mode(IXJ *j, int mode);
450 static int ixj_linetest(IXJ *j);
451 static int ixj_daa_write(IXJ *j);
452 static int ixj_daa_cid_read(IXJ *j);
453 static void DAA_Coeff_US(IXJ *j);
454 static void DAA_Coeff_UK(IXJ *j);
455 static void DAA_Coeff_France(IXJ *j);
456 static void DAA_Coeff_Germany(IXJ *j);
457 static void DAA_Coeff_Australia(IXJ *j);
458 static void DAA_Coeff_Japan(IXJ *j);
459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
464 /* Serial Control Interface funtions */
465 static int SCI_Control(IXJ *j, int control);
466 static int SCI_Prepare(IXJ *j);
467 static int SCI_WaitHighSCI(IXJ *j);
468 static int SCI_WaitLowSCI(IXJ *j);
469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
470 static int ixj_PCcontrol_wait(IXJ *j);
471 static void ixj_pre_cid(IXJ *j);
472 static void ixj_write_cid(IXJ *j);
473 static void ixj_write_cid_bit(IXJ *j, int bit);
474 static int set_base_frame(IXJ *j, int size);
475 static int set_play_codec(IXJ *j, int rate);
476 static void set_rec_depth(IXJ *j, int depth);
477 static int ixj_mixer(long val, IXJ *j);
478
479 /************************************************************************
480 CT8020/CT8021 Host Programmers Model
481 Host address Function Access
482 DSPbase +
483 0-1 Aux Software Status Register (reserved) Read Only
484 2-3 Software Status Register Read Only
485 4-5 Aux Software Control Register (reserved) Read Write
486 6-7 Software Control Register Read Write
487 8-9 Hardware Status Register Read Only
488 A-B Hardware Control Register Read Write
489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
490 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
491 ************************************************************************/
492
493 static inline void ixj_read_HSR(IXJ *j)
494 {
495 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
496 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
497 }
498
499 static inline int IsControlReady(IXJ *j)
500 {
501 ixj_read_HSR(j);
502 return j->hsr.bits.controlrdy ? 1 : 0;
503 }
504
505 static inline int IsPCControlReady(IXJ *j)
506 {
507 j->pccr1.byte = inb_p(j->XILINXbase + 3);
508 return j->pccr1.bits.crr ? 1 : 0;
509 }
510
511 static inline int IsStatusReady(IXJ *j)
512 {
513 ixj_read_HSR(j);
514 return j->hsr.bits.statusrdy ? 1 : 0;
515 }
516
517 static inline int IsRxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->rxreadycheck);
521 return j->hsr.bits.rxrdy ? 1 : 0;
522 }
523
524 static inline int IsTxReady(IXJ *j)
525 {
526 ixj_read_HSR(j);
527 ixj_perfmon(j->txreadycheck);
528 return j->hsr.bits.txrdy ? 1 : 0;
529 }
530
531 static inline void set_play_volume(IXJ *j, int volume)
532 {
533 if (ixjdebug & 0x0002)
534 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
535 ixj_WriteDSPCommand(0xCF02, j);
536 ixj_WriteDSPCommand(volume, j);
537 }
538
539 static int set_play_volume_linear(IXJ *j, int volume)
540 {
541 int newvolume, dspplaymax;
542
543 if (ixjdebug & 0x0002)
544 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
545 if(volume > 100 || volume < 0) {
546 return -1;
547 }
548
549 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
550 switch (j->cardtype) {
551 case QTI_PHONEJACK:
552 dspplaymax = 0x380;
553 break;
554 case QTI_LINEJACK:
555 if(j->port == PORT_PSTN) {
556 dspplaymax = 0x48;
557 } else {
558 dspplaymax = 0x100;
559 }
560 break;
561 case QTI_PHONEJACK_LITE:
562 dspplaymax = 0x380;
563 break;
564 case QTI_PHONEJACK_PCI:
565 dspplaymax = 0x6C;
566 break;
567 case QTI_PHONECARD:
568 dspplaymax = 0x50;
569 break;
570 default:
571 return -1;
572 }
573 newvolume = (dspplaymax * volume) / 100;
574 set_play_volume(j, newvolume);
575 return 0;
576 }
577
578 static inline void set_play_depth(IXJ *j, int depth)
579 {
580 if (depth > 60)
581 depth = 60;
582 if (depth < 0)
583 depth = 0;
584 ixj_WriteDSPCommand(0x5280 + depth, j);
585 }
586
587 static inline int get_play_volume(IXJ *j)
588 {
589 ixj_WriteDSPCommand(0xCF00, j);
590 return j->ssr.high << 8 | j->ssr.low;
591 }
592
593 static int get_play_volume_linear(IXJ *j)
594 {
595 int volume, newvolume, dspplaymax;
596
597 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
598 switch (j->cardtype) {
599 case QTI_PHONEJACK:
600 dspplaymax = 0x380;
601 break;
602 case QTI_LINEJACK:
603 if(j->port == PORT_PSTN) {
604 dspplaymax = 0x48;
605 } else {
606 dspplaymax = 0x100;
607 }
608 break;
609 case QTI_PHONEJACK_LITE:
610 dspplaymax = 0x380;
611 break;
612 case QTI_PHONEJACK_PCI:
613 dspplaymax = 0x6C;
614 break;
615 case QTI_PHONECARD:
616 dspplaymax = 100;
617 break;
618 default:
619 return -1;
620 }
621 volume = get_play_volume(j);
622 newvolume = (volume * 100) / dspplaymax;
623 if(newvolume > 100)
624 newvolume = 100;
625 return newvolume;
626 }
627
628 static inline BYTE SLIC_GetState(IXJ *j)
629 {
630 if (j->cardtype == QTI_PHONECARD) {
631 j->pccr1.byte = 0;
632 j->psccr.bits.dev = 3;
633 j->psccr.bits.rw = 1;
634 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
635 ixj_PCcontrol_wait(j);
636 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
637 ixj_PCcontrol_wait(j);
638 if (j->pslic.bits.powerdown)
639 return PLD_SLIC_STATE_OC;
640 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
641 return PLD_SLIC_STATE_ACTIVE;
642 else
643 return PLD_SLIC_STATE_RINGING;
644 } else {
645 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
646 }
647 return j->pld_slicr.bits.state;
648 }
649
650 static bool SLIC_SetState(BYTE byState, IXJ *j)
651 {
652 bool fRetVal = false;
653
654 if (j->cardtype == QTI_PHONECARD) {
655 if (j->flags.pcmciasct) {
656 switch (byState) {
657 case PLD_SLIC_STATE_TIPOPEN:
658 case PLD_SLIC_STATE_OC:
659 j->pslic.bits.powerdown = 1;
660 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
661 fRetVal = true;
662 break;
663 case PLD_SLIC_STATE_RINGING:
664 if (j->readers || j->writers) {
665 j->pslic.bits.powerdown = 0;
666 j->pslic.bits.ring0 = 1;
667 j->pslic.bits.ring1 = 0;
668 fRetVal = true;
669 }
670 break;
671 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
672
673 case PLD_SLIC_STATE_STANDBY:
674 case PLD_SLIC_STATE_ACTIVE:
675 if (j->readers || j->writers) {
676 j->pslic.bits.powerdown = 0;
677 } else {
678 j->pslic.bits.powerdown = 1;
679 }
680 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
681 fRetVal = true;
682 break;
683 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
684
685 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
686
687 default:
688 fRetVal = false;
689 break;
690 }
691 j->psccr.bits.dev = 3;
692 j->psccr.bits.rw = 0;
693 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
694 ixj_PCcontrol_wait(j);
695 }
696 } else {
697 /* Set the C1, C2, C3 & B2EN signals. */
698 switch (byState) {
699 case PLD_SLIC_STATE_OC:
700 j->pld_slicw.bits.c1 = 0;
701 j->pld_slicw.bits.c2 = 0;
702 j->pld_slicw.bits.c3 = 0;
703 j->pld_slicw.bits.b2en = 0;
704 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
705 fRetVal = true;
706 break;
707 case PLD_SLIC_STATE_RINGING:
708 j->pld_slicw.bits.c1 = 1;
709 j->pld_slicw.bits.c2 = 0;
710 j->pld_slicw.bits.c3 = 0;
711 j->pld_slicw.bits.b2en = 1;
712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
713 fRetVal = true;
714 break;
715 case PLD_SLIC_STATE_ACTIVE:
716 j->pld_slicw.bits.c1 = 0;
717 j->pld_slicw.bits.c2 = 1;
718 j->pld_slicw.bits.c3 = 0;
719 j->pld_slicw.bits.b2en = 0;
720 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
721 fRetVal = true;
722 break;
723 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
724
725 j->pld_slicw.bits.c1 = 1;
726 j->pld_slicw.bits.c2 = 1;
727 j->pld_slicw.bits.c3 = 0;
728 j->pld_slicw.bits.b2en = 0;
729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
730 fRetVal = true;
731 break;
732 case PLD_SLIC_STATE_TIPOPEN:
733 j->pld_slicw.bits.c1 = 0;
734 j->pld_slicw.bits.c2 = 0;
735 j->pld_slicw.bits.c3 = 1;
736 j->pld_slicw.bits.b2en = 0;
737 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
738 fRetVal = true;
739 break;
740 case PLD_SLIC_STATE_STANDBY:
741 j->pld_slicw.bits.c1 = 1;
742 j->pld_slicw.bits.c2 = 0;
743 j->pld_slicw.bits.c3 = 1;
744 j->pld_slicw.bits.b2en = 1;
745 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
746 fRetVal = true;
747 break;
748 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
749
750 j->pld_slicw.bits.c1 = 0;
751 j->pld_slicw.bits.c2 = 1;
752 j->pld_slicw.bits.c3 = 1;
753 j->pld_slicw.bits.b2en = 0;
754 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
755 fRetVal = true;
756 break;
757 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
758
759 j->pld_slicw.bits.c1 = 1;
760 j->pld_slicw.bits.c2 = 1;
761 j->pld_slicw.bits.c3 = 1;
762 j->pld_slicw.bits.b2en = 0;
763 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
764 fRetVal = true;
765 break;
766 default:
767 fRetVal = false;
768 break;
769 }
770 }
771
772 return fRetVal;
773 }
774
775 static int ixj_wink(IXJ *j)
776 {
777 BYTE slicnow;
778
779 slicnow = SLIC_GetState(j);
780
781 j->pots_winkstart = jiffies;
782 SLIC_SetState(PLD_SLIC_STATE_OC, j);
783
784 msleep(jiffies_to_msecs(j->winktime));
785
786 SLIC_SetState(slicnow, j);
787 return 0;
788 }
789
790 static void ixj_init_timer(IXJ *j)
791 {
792 init_timer(&j->timer);
793 j->timer.function = ixj_timeout;
794 j->timer.data = (unsigned long)j;
795 }
796
797 static void ixj_add_timer(IXJ *j)
798 {
799 j->timer.expires = jiffies + (hertz / samplerate);
800 add_timer(&j->timer);
801 }
802
803 static void ixj_tone_timeout(IXJ *j)
804 {
805 IXJ_TONE ti;
806
807 j->tone_state++;
808 if (j->tone_state == 3) {
809 j->tone_state = 0;
810 if (j->cadence_t) {
811 j->tone_cadence_state++;
812 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
813 switch (j->cadence_t->termination) {
814 case PLAY_ONCE:
815 ixj_cpt_stop(j);
816 break;
817 case REPEAT_LAST_ELEMENT:
818 j->tone_cadence_state--;
819 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
820 break;
821 case REPEAT_ALL:
822 j->tone_cadence_state = 0;
823 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
824 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
825 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
826 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
827 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
828 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
829 ixj_init_tone(j, &ti);
830 }
831 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
832 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
833 ixj_play_tone(j, j->cadence_t->ce[0].index);
834 break;
835 }
836 } else {
837 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
838 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
839 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
840 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
841 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
842 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
843 ixj_init_tone(j, &ti);
844 }
845 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
846 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
847 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
848 }
849 }
850 }
851 }
852
853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
854 {
855 if(j->ixj_signals[event]) {
856 if(ixjdebug & 0x0100)
857 printk("Sending signal for event %d\n", event);
858 /* Send apps notice of change */
859 /* see config.h for macro definition */
860 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
861 }
862 }
863
864 static void ixj_pstn_state(IXJ *j)
865 {
866 int var;
867 union XOPXR0 XR0, daaint;
868
869 var = 10;
870
871 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
872 daaint.reg = 0;
873 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
874
875 j->pld_scrr.byte = inb_p(j->XILINXbase);
876 if (j->pld_scrr.bits.daaflag) {
877 daa_int_read(j);
878 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
879 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
880 daaint.bitreg.RING = 1;
881 if(ixjdebug & 0x0008) {
882 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
883 }
884 } else {
885 daa_set_mode(j, SOP_PU_RESET);
886 }
887 }
888 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
889 daaint.bitreg.Caller_ID = 1;
890 j->pstn_cid_intr = 1;
891 j->pstn_cid_received = jiffies;
892 if(ixjdebug & 0x0008) {
893 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
894 }
895 }
896 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
897 daaint.bitreg.Cadence = 1;
898 if(ixjdebug & 0x0008) {
899 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
900 }
901 }
902 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
903 daaint.bitreg.VDD_OK = 1;
904 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
905 }
906 }
907 daa_CR_read(j, 1);
908 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
909 daaint.bitreg.RMR = 1;
910 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
911 if(ixjdebug & 0x0008) {
912 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
913 }
914 j->pstn_prev_rmr = j->pstn_last_rmr;
915 j->pstn_last_rmr = jiffies;
916 }
917 switch(j->daa_mode) {
918 case SOP_PU_SLEEP:
919 if (daaint.bitreg.RING) {
920 if (!j->flags.pstn_ringing) {
921 if (j->daa_mode != SOP_PU_RINGING) {
922 j->pstn_ring_int = jiffies;
923 daa_set_mode(j, SOP_PU_RINGING);
924 }
925 }
926 }
927 break;
928 case SOP_PU_RINGING:
929 if (daaint.bitreg.RMR) {
930 if (ixjdebug & 0x0008) {
931 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
932 }
933 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
934 j->flags.pstn_rmr = 1;
935 j->pstn_ring_start = jiffies;
936 j->pstn_ring_stop = 0;
937 j->ex.bits.pstn_ring = 0;
938 if (j->cadence_f[4].state == 0) {
939 j->cadence_f[4].state = 1;
940 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
941 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
942 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
943 } else if (j->cadence_f[4].state == 2) {
944 if((time_after(jiffies, j->cadence_f[4].off1min) &&
945 time_before(jiffies, j->cadence_f[4].off1max))) {
946 if (j->cadence_f[4].on2) {
947 j->cadence_f[4].state = 3;
948 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
949 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
950 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
951 } else {
952 j->cadence_f[4].state = 7;
953 }
954 } else {
955 if (ixjdebug & 0x0008) {
956 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
957 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
958 j->cadence_f[4].off1);
959 }
960 j->cadence_f[4].state = 0;
961 }
962 } else if (j->cadence_f[4].state == 4) {
963 if((time_after(jiffies, j->cadence_f[4].off2min) &&
964 time_before(jiffies, j->cadence_f[4].off2max))) {
965 if (j->cadence_f[4].on3) {
966 j->cadence_f[4].state = 5;
967 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
968 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
969 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
970 } else {
971 j->cadence_f[4].state = 7;
972 }
973 } else {
974 if (ixjdebug & 0x0008) {
975 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
976 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
977 j->cadence_f[4].off2);
978 }
979 j->cadence_f[4].state = 0;
980 }
981 } else if (j->cadence_f[4].state == 6) {
982 if((time_after(jiffies, j->cadence_f[4].off3min) &&
983 time_before(jiffies, j->cadence_f[4].off3max))) {
984 j->cadence_f[4].state = 7;
985 } else {
986 if (ixjdebug & 0x0008) {
987 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
988 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
989 j->cadence_f[4].off3);
990 }
991 j->cadence_f[4].state = 0;
992 }
993 } else {
994 j->cadence_f[4].state = 0;
995 }
996 } else { /* Falling edge of RMR */
997 j->pstn_ring_start = 0;
998 j->pstn_ring_stop = jiffies;
999 if (j->cadence_f[4].state == 1) {
1000 if(!j->cadence_f[4].on1) {
1001 j->cadence_f[4].state = 7;
1002 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003 time_before(jiffies, j->cadence_f[4].on1max))) {
1004 if (j->cadence_f[4].off1) {
1005 j->cadence_f[4].state = 2;
1006 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009 } else {
1010 j->cadence_f[4].state = 7;
1011 }
1012 } else {
1013 if (ixjdebug & 0x0008) {
1014 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016 j->cadence_f[4].on1);
1017 }
1018 j->cadence_f[4].state = 0;
1019 }
1020 } else if (j->cadence_f[4].state == 3) {
1021 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022 time_before(jiffies, j->cadence_f[4].on2max))) {
1023 if (j->cadence_f[4].off2) {
1024 j->cadence_f[4].state = 4;
1025 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028 } else {
1029 j->cadence_f[4].state = 7;
1030 }
1031 } else {
1032 if (ixjdebug & 0x0008) {
1033 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035 j->cadence_f[4].on2);
1036 }
1037 j->cadence_f[4].state = 0;
1038 }
1039 } else if (j->cadence_f[4].state == 5) {
1040 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041 time_before(jiffies, j->cadence_f[4].on3max))) {
1042 if (j->cadence_f[4].off3) {
1043 j->cadence_f[4].state = 6;
1044 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 j->cadence_f[4].state = 0;
1052 }
1053 } else {
1054 if (ixjdebug & 0x0008) {
1055 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057 j->cadence_f[4].on3);
1058 }
1059 j->cadence_f[4].state = 0;
1060 }
1061 }
1062 if (ixjdebug & 0x0010) {
1063 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064 }
1065 if (ixjdebug & 0x0010) {
1066 switch(j->cadence_f[4].state) {
1067 case 1:
1068 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070 break;
1071 case 2:
1072 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074 break;
1075 case 3:
1076 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078 break;
1079 case 4:
1080 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082 break;
1083 case 5:
1084 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086 break;
1087 case 6:
1088 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090 break;
1091 }
1092 }
1093 }
1094 if (j->cadence_f[4].state == 7) {
1095 j->cadence_f[4].state = 0;
1096 j->pstn_ring_stop = jiffies;
1097 j->ex.bits.pstn_ring = 1;
1098 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099 if(ixjdebug & 0x0008) {
1100 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101 }
1102 }
1103 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105 if(ixjdebug & 0x0008) {
1106 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109 }
1110 j->pstn_ring_stop = j->pstn_ring_int = 0;
1111 daa_set_mode(j, SOP_PU_SLEEP);
1112 }
1113 outb_p(j->pld_scrw.byte, j->XILINXbase);
1114 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115 ixj_daa_cid_read(j);
1116 j->ex.bits.caller_id = 1;
1117 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118 j->pstn_cid_intr = 0;
1119 }
1120 if (daaint.bitreg.Cadence) {
1121 if(ixjdebug & 0x0008) {
1122 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123 }
1124 daa_set_mode(j, SOP_PU_SLEEP);
1125 j->ex.bits.pstn_ring = 0;
1126 }
1127 break;
1128 case SOP_PU_CONVERSATION:
1129 if (daaint.bitreg.VDD_OK) {
1130 if(!daaint.bitreg.SI_0) {
1131 if (!j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = jiffies;
1136 }
1137 } else {
1138 if (j->pstn_winkstart) {
1139 if(ixjdebug & 0x0008) {
1140 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141 }
1142 j->pstn_winkstart = 0;
1143 }
1144 }
1145 }
1146 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147 if(ixjdebug & 0x0008) {
1148 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149 }
1150 daa_set_mode(j, SOP_PU_SLEEP);
1151 j->pstn_winkstart = 0;
1152 j->ex.bits.pstn_wink = 1;
1153 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154 }
1155 break;
1156 }
1157 }
1158
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161 int board;
1162 unsigned long jifon;
1163 IXJ *j = (IXJ *)ptr;
1164 board = j->board;
1165
1166 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167 ixj_perfmon(j->timerchecks);
1168 j->hookstate = ixj_hookstate(j);
1169 if (j->tone_state) {
1170 if (!(j->hookstate)) {
1171 ixj_cpt_stop(j);
1172 if (j->m_hook) {
1173 j->m_hook = 0;
1174 j->ex.bits.hookstate = 1;
1175 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176 }
1177 clear_bit(board, &j->busyflags);
1178 ixj_add_timer(j);
1179 return;
1180 }
1181 if (j->tone_state == 1)
1182 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183 else
1184 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186 if (j->tone_state == 1) {
1187 ixj_play_tone(j, j->tone_index);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 } else {
1194 ixj_play_tone(j, 0);
1195 if (j->dsp.low == 0x20) {
1196 clear_bit(board, &j->busyflags);
1197 ixj_add_timer(j);
1198 return;
1199 }
1200 }
1201 } else {
1202 ixj_tone_timeout(j);
1203 if (j->flags.dialtone) {
1204 ixj_dialtone(j);
1205 }
1206 if (j->flags.busytone) {
1207 ixj_busytone(j);
1208 if (j->dsp.low == 0x20) {
1209 clear_bit(board, &j->busyflags);
1210 ixj_add_timer(j);
1211 return;
1212 }
1213 }
1214 if (j->flags.ringback) {
1215 ixj_ringback(j);
1216 if (j->dsp.low == 0x20) {
1217 clear_bit(board, &j->busyflags);
1218 ixj_add_timer(j);
1219 return;
1220 }
1221 }
1222 if (!j->tone_state) {
1223 ixj_cpt_stop(j);
1224 }
1225 }
1226 }
1227 if (!(j->tone_state && j->dsp.low == 0x20)) {
1228 if (IsRxReady(j)) {
1229 ixj_read_frame(j);
1230 }
1231 if (IsTxReady(j)) {
1232 ixj_write_frame(j);
1233 }
1234 }
1235 if (j->flags.cringing) {
1236 if (j->hookstate & 1) {
1237 j->flags.cringing = 0;
1238 ixj_ring_off(j);
1239 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240 switch(j->cadence_f[5].state) {
1241 case 0:
1242 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244 if(ixjdebug & 0x0004) {
1245 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246 }
1247 ixj_ring_on(j);
1248 }
1249 j->cadence_f[5].state = 1;
1250 break;
1251 case 1:
1252 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254 if(ixjdebug & 0x0004) {
1255 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256 }
1257 ixj_ring_off(j);
1258 j->cadence_f[5].state = 2;
1259 }
1260 break;
1261 case 2:
1262 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263 if(ixjdebug & 0x0004) {
1264 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265 }
1266 ixj_ring_on(j);
1267 if (j->cadence_f[5].on2) {
1268 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269 j->cadence_f[5].state = 3;
1270 } else {
1271 j->cadence_f[5].state = 7;
1272 }
1273 }
1274 break;
1275 case 3:
1276 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277 if(ixjdebug & 0x0004) {
1278 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279 }
1280 ixj_ring_off(j);
1281 if (j->cadence_f[5].off2) {
1282 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283 j->cadence_f[5].state = 4;
1284 } else {
1285 j->cadence_f[5].state = 7;
1286 }
1287 }
1288 break;
1289 case 4:
1290 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291 if(ixjdebug & 0x0004) {
1292 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293 }
1294 ixj_ring_on(j);
1295 if (j->cadence_f[5].on3) {
1296 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297 j->cadence_f[5].state = 5;
1298 } else {
1299 j->cadence_f[5].state = 7;
1300 }
1301 }
1302 break;
1303 case 5:
1304 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305 if(ixjdebug & 0x0004) {
1306 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307 }
1308 ixj_ring_off(j);
1309 if (j->cadence_f[5].off3) {
1310 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311 j->cadence_f[5].state = 6;
1312 } else {
1313 j->cadence_f[5].state = 7;
1314 }
1315 }
1316 break;
1317 case 6:
1318 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->cadence_f[5].state = 7;
1323 }
1324 break;
1325 case 7:
1326 if(ixjdebug & 0x0004) {
1327 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328 }
1329 j->flags.cidring = 1;
1330 j->cadence_f[5].state = 0;
1331 break;
1332 }
1333 if (j->flags.cidring && !j->flags.cidsent) {
1334 j->flags.cidsent = 1;
1335 if(j->fskdcnt) {
1336 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337 ixj_pre_cid(j);
1338 }
1339 j->flags.cidring = 0;
1340 }
1341 clear_bit(board, &j->busyflags);
1342 ixj_add_timer(j);
1343 return;
1344 } else {
1345 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346 if (j->flags.cidring && !j->flags.cidsent) {
1347 j->flags.cidsent = 1;
1348 if(j->fskdcnt) {
1349 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350 ixj_pre_cid(j);
1351 }
1352 j->flags.cidring = 0;
1353 }
1354 j->ring_cadence_t--;
1355 if (j->ring_cadence_t == -1)
1356 j->ring_cadence_t = 15;
1357 j->ring_cadence_jif = jiffies;
1358
1359 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361 j->flags.firstring = 1;
1362 else
1363 ixj_ring_on(j);
1364 } else {
1365 ixj_ring_off(j);
1366 if(!j->flags.cidsent)
1367 j->flags.cidring = 1;
1368 }
1369 }
1370 clear_bit(board, &j->busyflags);
1371 ixj_add_timer(j);
1372 return;
1373 }
1374 }
1375 if (!j->flags.ringing) {
1376 if (j->hookstate) { /* & 1) { */
1377 if (j->dsp.low != 0x20 &&
1378 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380 }
1381 LineMonitor(j);
1382 read_filters(j);
1383 ixj_WriteDSPCommand(0x511B, j);
1384 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385 if (!j->m_hook && (j->hookstate & 1)) {
1386 j->m_hook = j->ex.bits.hookstate = 1;
1387 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388 }
1389 } else {
1390 if (j->ex.bits.dtmf_ready) {
1391 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392 }
1393 if (j->m_hook) {
1394 j->m_hook = 0;
1395 j->ex.bits.hookstate = 1;
1396 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397 }
1398 }
1399 }
1400 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401 ixj_pstn_state(j);
1402 }
1403 if (j->ex.bytes) {
1404 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1405 }
1406 clear_bit(board, &j->busyflags);
1407 }
1408 ixj_add_timer(j);
1409 }
1410
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413 unsigned long jif;
1414
1415 jif = jiffies + ((60 * hertz) / 100);
1416 while (!IsStatusReady(j)) {
1417 ixj_perfmon(j->statuswait);
1418 if (time_after(jiffies, jif)) {
1419 ixj_perfmon(j->statuswaitfail);
1420 return -1;
1421 }
1422 }
1423 return 0;
1424 }
1425
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428 unsigned long jif;
1429
1430 jif = jiffies + ((60 * hertz) / 100);
1431 while (!IsPCControlReady(j)) {
1432 ixj_perfmon(j->pcontrolwait);
1433 if (time_after(jiffies, jif)) {
1434 ixj_perfmon(j->pcontrolwaitfail);
1435 return -1;
1436 }
1437 }
1438 return 0;
1439 }
1440
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443 BYTES bytes;
1444 unsigned long jif;
1445
1446 atomic_inc(&j->DSPWrite);
1447 if(atomic_read(&j->DSPWrite) > 1) {
1448 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449 return -1;
1450 }
1451 bytes.high = (cmd & 0xFF00) >> 8;
1452 bytes.low = cmd & 0x00FF;
1453 jif = jiffies + ((60 * hertz) / 100);
1454 while (!IsControlReady(j)) {
1455 ixj_perfmon(j->iscontrolready);
1456 if (time_after(jiffies, jif)) {
1457 ixj_perfmon(j->iscontrolreadyfail);
1458 atomic_dec(&j->DSPWrite);
1459 if(atomic_read(&j->DSPWrite) > 0) {
1460 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461 while(atomic_read(&j->DSPWrite) > 0) {
1462 atomic_dec(&j->DSPWrite);
1463 }
1464 }
1465 return -1;
1466 }
1467 }
1468 outb(bytes.low, j->DSPbase + 6);
1469 outb(bytes.high, j->DSPbase + 7);
1470
1471 if (ixj_status_wait(j)) {
1472 j->ssr.low = 0xFF;
1473 j->ssr.high = 0xFF;
1474 atomic_dec(&j->DSPWrite);
1475 if(atomic_read(&j->DSPWrite) > 0) {
1476 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477 while(atomic_read(&j->DSPWrite) > 0) {
1478 atomic_dec(&j->DSPWrite);
1479 }
1480 }
1481 return -1;
1482 }
1483 /* Read Software Status Register */
1484 j->ssr.low = inb_p(j->DSPbase + 2);
1485 j->ssr.high = inb_p(j->DSPbase + 3);
1486 atomic_dec(&j->DSPWrite);
1487 if(atomic_read(&j->DSPWrite) > 0) {
1488 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489 while(atomic_read(&j->DSPWrite) > 0) {
1490 atomic_dec(&j->DSPWrite);
1491 }
1492 }
1493 return 0;
1494 }
1495
1496 /***************************************************************************
1497 *
1498 * General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503 if (ixj_WriteDSPCommand(0x5143, j))
1504 return -1;
1505
1506 j->gpio.bytes.low = j->ssr.low;
1507 j->gpio.bytes.high = j->ssr.high;
1508
1509 return 0;
1510 }
1511
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514 if (j->cardtype == QTI_LINEJACK) {
1515 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520 outb(j->pld_scrw.byte, j->XILINXbase);
1521 }
1522 }
1523
1524 /*********************************************************************
1525 * GPIO Pins are configured as follows on the Quicknet Internet
1526 * PhoneJACK Telephony Cards
1527 *
1528 * POTS Select GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540 if (j->cardtype == QTI_PHONEJACK_LITE) {
1541 if (arg != PORT_POTS)
1542 return 10;
1543 else
1544 return 0;
1545 }
1546 switch (arg) {
1547 case PORT_POTS:
1548 j->port = PORT_POTS;
1549 switch (j->cardtype) {
1550 case QTI_PHONECARD:
1551 if (j->flags.pcmciasct == 1)
1552 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553 else
1554 return 11;
1555 break;
1556 case QTI_PHONEJACK_PCI:
1557 j->pld_slicw.pcib.mic = 0;
1558 j->pld_slicw.pcib.spk = 0;
1559 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560 break;
1561 case QTI_LINEJACK:
1562 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1563 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1564 Software Control Register */
1565 return 2;
1566 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1567
1568 outb(j->pld_scrw.byte, j->XILINXbase);
1569 j->pld_clock.byte = 0;
1570 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571 j->pld_slicw.bits.rly1 = 1;
1572 j->pld_slicw.bits.spken = 0;
1573 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1575 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1576 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1577 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1578 ixj_mixer(0x0E80, j); /*Mic mute */
1579 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1580 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1581 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1582 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584 break;
1585 case QTI_PHONEJACK:
1586 j->gpio.bytes.high = 0x0B;
1587 j->gpio.bits.gpio6 = 0;
1588 j->gpio.bits.gpio7 = 0;
1589 ixj_WriteDSPCommand(j->gpio.word, j);
1590 break;
1591 }
1592 break;
1593 case PORT_PSTN:
1594 if (j->cardtype == QTI_LINEJACK) {
1595 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597 j->pld_slicw.bits.rly3 = 0;
1598 j->pld_slicw.bits.rly1 = 1;
1599 j->pld_slicw.bits.spken = 0;
1600 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601 j->port = PORT_PSTN;
1602 } else {
1603 return 4;
1604 }
1605 break;
1606 case PORT_SPEAKER:
1607 j->port = PORT_SPEAKER;
1608 switch (j->cardtype) {
1609 case QTI_PHONECARD:
1610 if (j->flags.pcmciasct) {
1611 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612 }
1613 break;
1614 case QTI_PHONEJACK_PCI:
1615 j->pld_slicw.pcib.mic = 1;
1616 j->pld_slicw.pcib.spk = 1;
1617 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618 break;
1619 case QTI_LINEJACK:
1620 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1621 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1622 Software Control Register */
1623 return 2;
1624 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1625
1626 outb(j->pld_scrw.byte, j->XILINXbase);
1627 j->pld_clock.byte = 0;
1628 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629 j->pld_slicw.bits.rly1 = 1;
1630 j->pld_slicw.bits.spken = 1;
1631 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1633 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1634 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1635 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1636 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1637 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1638 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1639 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1640 break;
1641 case QTI_PHONEJACK:
1642 j->gpio.bytes.high = 0x0B;
1643 j->gpio.bits.gpio6 = 0;
1644 j->gpio.bits.gpio7 = 1;
1645 ixj_WriteDSPCommand(j->gpio.word, j);
1646 break;
1647 }
1648 break;
1649 case PORT_HANDSET:
1650 if (j->cardtype != QTI_PHONEJACK) {
1651 return 5;
1652 } else {
1653 j->gpio.bytes.high = 0x0B;
1654 j->gpio.bits.gpio6 = 1;
1655 j->gpio.bits.gpio7 = 0;
1656 ixj_WriteDSPCommand(j->gpio.word, j);
1657 j->port = PORT_HANDSET;
1658 }
1659 break;
1660 default:
1661 return 6;
1662 break;
1663 }
1664 return 0;
1665 }
1666
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669 if (j->cardtype == QTI_LINEJACK) {
1670 if (arg) {
1671 if (j->port == PORT_PSTN) {
1672 j->pld_slicw.bits.rly1 = 0;
1673 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674 j->flags.pots_pstn = 1;
1675 return 1;
1676 } else {
1677 j->flags.pots_pstn = 0;
1678 return 0;
1679 }
1680 } else {
1681 j->pld_slicw.bits.rly1 = 1;
1682 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683 j->flags.pots_pstn = 0;
1684 return 1;
1685 }
1686 } else {
1687 return 0;
1688 }
1689 }
1690
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694 {
1695 if (ixjdebug & 0x0004)
1696 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1697
1698 j->gpio.bytes.high = 0x0B;
1699 j->gpio.bytes.low = 0x00;
1700 j->gpio.bits.gpio1 = 1;
1701 j->gpio.bits.gpio2 = 1;
1702 j->gpio.bits.gpio5 = 0;
1703 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1704 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705 {
1706 if (ixjdebug & 0x0004)
1707 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710 }
1711 }
1712
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715 if(j->cardtype == QTI_PHONECARD){
1716 if(j->flags.pcmciascp){
1717 if(val == -1)
1718 return j->siadc.bits.rxg;
1719
1720 if(val < 0 || val > 0x1F)
1721 return -1;
1722
1723 j->siadc.bits.hom = 0; /* Handset Out Mute */
1724 j->siadc.bits.lom = 0; /* Line Out Mute */
1725 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1726 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1727 j->psccr.bits.rw = 0; /* Read / Write flag */
1728 j->psccr.bits.dev = 0;
1729 outb(j->siadc.byte, j->XILINXbase + 0x00);
1730 outb(j->psccr.byte, j->XILINXbase + 0x01);
1731 ixj_PCcontrol_wait(j);
1732 return j->siadc.bits.rxg;
1733 }
1734 }
1735 return -1;
1736 }
1737
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740 if(j->cardtype == QTI_PHONECARD){
1741 if(j->flags.pcmciascp){
1742 if(val == -1)
1743 return j->sidac.bits.txg;
1744
1745 if(val < 0 || val > 0x1F)
1746 return -1;
1747
1748 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1749 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1750 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1751 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1752 j->psccr.bits.rw = 0; /* Read / Write flag */
1753 j->psccr.bits.dev = 0;
1754 outb(j->sidac.byte, j->XILINXbase + 0x00);
1755 outb(j->psccr.byte, j->XILINXbase + 0x01);
1756 ixj_PCcontrol_wait(j);
1757 return j->sidac.bits.txg;
1758 }
1759 }
1760 return -1;
1761 }
1762
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766 if (!j->flags.pcmciastate) {
1767 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769 j->flags.pcmciastate = 4;
1770 return 0;
1771 }
1772 if (j->pccr1.bits.ed) {
1773 j->pccr1.bits.ed = 0;
1774 j->psccr.bits.dev = 3;
1775 j->psccr.bits.rw = 1;
1776 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777 ixj_PCcontrol_wait(j);
1778 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780 j->psccr.bits.dev = 3;
1781 j->psccr.bits.rw = 0;
1782 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783 ixj_PCcontrol_wait(j);
1784 return j->pslic.bits.led2 ? 1 : 0;
1785 } else if (j->flags.pcmciasct) {
1786 return j->r_hook;
1787 } else {
1788 return 1;
1789 }
1790 } else if (j->flags.pcmciastate == 4) {
1791 if (!j->pccr1.bits.drf) {
1792 j->flags.pcmciastate = 3;
1793 }
1794 return 0;
1795 } else if (j->flags.pcmciastate == 3) {
1796 j->pccr2.bits.pwr = 0;
1797 j->pccr2.bits.rstc = 1;
1798 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799 j->checkwait = jiffies + (hertz * 2);
1800 j->flags.incheck = 1;
1801 j->flags.pcmciastate = 2;
1802 return 0;
1803 } else if (j->flags.pcmciastate == 2) {
1804 if (j->flags.incheck) {
1805 if (time_before(jiffies, j->checkwait)) {
1806 return 0;
1807 } else {
1808 j->flags.incheck = 0;
1809 }
1810 }
1811 j->pccr2.bits.pwr = 0;
1812 j->pccr2.bits.rstc = 0;
1813 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814 j->flags.pcmciastate = 1;
1815 return 0;
1816 } else if (j->flags.pcmciastate == 1) {
1817 j->flags.pcmciastate = 0;
1818 if (!j->pccr1.bits.drf) {
1819 j->psccr.bits.dev = 3;
1820 j->psccr.bits.rw = 1;
1821 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822 ixj_PCcontrol_wait(j);
1823 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1824
1825 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1826
1827 if (j->flags.pcmciasct == 3) {
1828 j->flags.pcmciastate = 4;
1829 return 0;
1830 } else if (j->flags.pcmciasct == 0) {
1831 j->pccr2.bits.pwr = 1;
1832 j->pccr2.bits.rstc = 0;
1833 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834 j->port = PORT_SPEAKER;
1835 } else {
1836 j->port = PORT_POTS;
1837 }
1838 j->sic1.bits.cpd = 0; /* Chip Power Down */
1839 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1840 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1841 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1842 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1843 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1844 j->psccr.bits.rw = 0; /* Read / Write flag */
1845 j->psccr.bits.dev = 0;
1846 outb(j->sic1.byte, j->XILINXbase + 0x00);
1847 outb(j->psccr.byte, j->XILINXbase + 0x01);
1848 ixj_PCcontrol_wait(j);
1849
1850 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1851 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1852 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1853 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1854 j->sic2.bits.hpd = 0; /* HPF disable */
1855 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(j->sic2.byte, j->XILINXbase + 0x00);
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1870 j->psccr.bits.rw = 0; /* Read / Write flag */
1871 j->psccr.bits.dev = 0;
1872 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1873 outb(j->psccr.byte, j->XILINXbase + 0x01);
1874 ixj_PCcontrol_wait(j);
1875
1876 j->sirxg.bits.lig = 1; /* Line In Gain */
1877 j->sirxg.bits.lim = 1; /* Line In Mute */
1878 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1879 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1880 j->sirxg.bits.him = 0; /* Handset In Mute */
1881 j->sirxg.bits.iir = 1; /* IIR */
1882 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1883 j->psccr.bits.rw = 0; /* Read / Write flag */
1884 j->psccr.bits.dev = 0;
1885 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886 outb(j->psccr.byte, j->XILINXbase + 0x01);
1887 ixj_PCcontrol_wait(j);
1888
1889 ixj_siadc(j, 0x17);
1890 ixj_sidac(j, 0x1D);
1891
1892 j->siaatt.bits.sot = 0;
1893 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1894 j->psccr.bits.rw = 0; /* Read / Write flag */
1895 j->psccr.bits.dev = 0;
1896 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897 outb(j->psccr.byte, j->XILINXbase + 0x01);
1898 ixj_PCcontrol_wait(j);
1899
1900 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901 j->psccr.byte = j->pslic.byte = 0;
1902 j->pslic.bits.powerdown = 1;
1903 j->psccr.bits.dev = 3;
1904 j->psccr.bits.rw = 0;
1905 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906 ixj_PCcontrol_wait(j);
1907 }
1908 }
1909 return 0;
1910 } else {
1911 j->flags.pcmciascp = 0;
1912 return 0;
1913 }
1914 return 0;
1915 }
1916
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919 int fOffHook = 0;
1920
1921 switch (j->cardtype) {
1922 case QTI_PHONEJACK:
1923 ixj_gpio_read(j);
1924 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925 break;
1926 case QTI_LINEJACK:
1927 case QTI_PHONEJACK_LITE:
1928 case QTI_PHONEJACK_PCI:
1929 SLIC_GetState(j);
1930 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932 if(fOffHook != j->p_hook) {
1933 if(!j->checkwait) {
1934 j->checkwait = jiffies;
1935 }
1936 if(time_before(jiffies, j->checkwait + 2)) {
1937 fOffHook ^= 1;
1938 } else {
1939 j->checkwait = 0;
1940 }
1941 j->p_hook = fOffHook;
1942 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943 }
1944 } else {
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947 if (j->flags.ringing || j->flags.cringing) {
1948 if (!in_interrupt()) {
1949 msleep(20);
1950 }
1951 SLIC_GetState(j);
1952 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953 ixj_ring_on(j);
1954 }
1955 }
1956 if (j->cardtype == QTI_PHONEJACK_PCI) {
1957 j->pld_scrr.byte = inb_p(j->XILINXbase);
1958 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959 } else
1960 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961 }
1962 }
1963 break;
1964 case QTI_PHONECARD:
1965 fOffHook = ixj_pcmcia_cable_check(j);
1966 break;
1967 }
1968 if (j->r_hook != fOffHook) {
1969 j->r_hook = fOffHook;
1970 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971 j->ex.bits.hookstate = 1;
1972 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973 } else if (!fOffHook) {
1974 j->flash_end = jiffies + ((60 * hertz) / 100);
1975 }
1976 }
1977 if (fOffHook) {
1978 if(time_before(jiffies, j->flash_end)) {
1979 j->ex.bits.flash = 1;
1980 j->flash_end = 0;
1981 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982 }
1983 } else {
1984 if(time_before(jiffies, j->flash_end)) {
1985 fOffHook = 1;
1986 }
1987 }
1988
1989 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990 fOffHook |= 2;
1991
1992 if (j->port == PORT_SPEAKER) {
1993 if(j->cardtype == QTI_PHONECARD) {
1994 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995 fOffHook |= 2;
1996 }
1997 } else {
1998 fOffHook |= 2;
1999 }
2000 }
2001
2002 if (j->port == PORT_HANDSET)
2003 fOffHook |= 2;
2004
2005 return fOffHook;
2006 }
2007
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011 {
2012 if (ixjdebug & 0x0004)
2013 printk(KERN_INFO "IXJ Ring Off\n");
2014 j->gpio.bytes.high = 0x0B;
2015 j->gpio.bytes.low = 0x00;
2016 j->gpio.bits.gpio1 = 0;
2017 j->gpio.bits.gpio2 = 1;
2018 j->gpio.bits.gpio5 = 0;
2019 ixj_WriteDSPCommand(j->gpio.word, j);
2020 } else /* Internet LineJACK */
2021 {
2022 if (ixjdebug & 0x0004)
2023 printk(KERN_INFO "IXJ Ring Off\n");
2024
2025 if(!j->flags.cidplay)
2026 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028 SLIC_GetState(j);
2029 }
2030 }
2031
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034 j->flags.cringing = 1;
2035 if (ixjdebug & 0x0004)
2036 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037 if (ixj_hookstate(j) & 1) {
2038 if (j->port == PORT_POTS)
2039 ixj_ring_off(j);
2040 j->flags.cringing = 0;
2041 if (ixjdebug & 0x0004)
2042 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044 j->ring_cadence_jif = jiffies;
2045 j->flags.cidsent = j->flags.cidring = 0;
2046 j->cadence_f[5].state = 0;
2047 if(j->cadence_f[5].on1)
2048 ixj_ring_on(j);
2049 } else {
2050 j->ring_cadence_jif = jiffies;
2051 j->ring_cadence_t = 15;
2052 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053 ixj_ring_on(j);
2054 } else {
2055 ixj_ring_off(j);
2056 }
2057 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058 }
2059 }
2060
2061 static int ixj_ring(IXJ *j)
2062 {
2063 char cntr;
2064 unsigned long jif;
2065
2066 j->flags.ringing = 1;
2067 if (ixj_hookstate(j) & 1) {
2068 ixj_ring_off(j);
2069 j->flags.ringing = 0;
2070 return 1;
2071 }
2072 for (cntr = 0; cntr < j->maxrings; cntr++) {
2073 jif = jiffies + (1 * hertz);
2074 ixj_ring_on(j);
2075 while (time_before(jiffies, jif)) {
2076 if (ixj_hookstate(j) & 1) {
2077 ixj_ring_off(j);
2078 j->flags.ringing = 0;
2079 return 1;
2080 }
2081 schedule_timeout_interruptible(1);
2082 if (signal_pending(current))
2083 break;
2084 }
2085 jif = jiffies + (3 * hertz);
2086 ixj_ring_off(j);
2087 while (time_before(jiffies, jif)) {
2088 if (ixj_hookstate(j) & 1) {
2089 msleep(10);
2090 if (ixj_hookstate(j) & 1) {
2091 j->flags.ringing = 0;
2092 return 1;
2093 }
2094 }
2095 schedule_timeout_interruptible(1);
2096 if (signal_pending(current))
2097 break;
2098 }
2099 }
2100 ixj_ring_off(j);
2101 j->flags.ringing = 0;
2102 return 0;
2103 }
2104
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107 IXJ *j = get_ixj(p->board);
2108 file_p->private_data = j;
2109
2110 if (!j->DSPbase)
2111 return -ENODEV;
2112
2113 if (file_p->f_mode & FMODE_READ) {
2114 if(!j->readers) {
2115 j->readers++;
2116 } else {
2117 return -EBUSY;
2118 }
2119 }
2120
2121 if (file_p->f_mode & FMODE_WRITE) {
2122 if(!j->writers) {
2123 j->writers++;
2124 } else {
2125 if (file_p->f_mode & FMODE_READ){
2126 j->readers--;
2127 }
2128 return -EBUSY;
2129 }
2130 }
2131
2132 if (j->cardtype == QTI_PHONECARD) {
2133 j->pslic.bits.powerdown = 0;
2134 j->psccr.bits.dev = 3;
2135 j->psccr.bits.rw = 0;
2136 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137 ixj_PCcontrol_wait(j);
2138 }
2139
2140 j->flags.cidplay = 0;
2141 j->flags.cidcw_ack = 0;
2142
2143 if (ixjdebug & 0x0002)
2144 printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146 j->framesread = j->frameswritten = 0;
2147 return 0;
2148 }
2149
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152 IXJ_TONE ti;
2153 int cnt;
2154 IXJ *j = file_p->private_data;
2155 int board = j->p.board;
2156
2157 /*
2158 * Set up locks to ensure that only one process is talking to the DSP at a time.
2159 * This is necessary to keep the DSP from locking up.
2160 */
2161 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162 schedule_timeout_interruptible(1);
2163 if (ixjdebug & 0x0002)
2164 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166 if (j->cardtype == QTI_PHONECARD)
2167 ixj_set_port(j, PORT_SPEAKER);
2168 else
2169 ixj_set_port(j, PORT_POTS);
2170
2171 aec_stop(j);
2172 ixj_play_stop(j);
2173 ixj_record_stop(j);
2174 set_play_volume(j, 0x100);
2175 set_rec_volume(j, 0x100);
2176 ixj_ring_off(j);
2177
2178 /* Restore the tone table to default settings. */
2179 ti.tone_index = 10;
2180 ti.gain0 = 1;
2181 ti.freq0 = hz941;
2182 ti.gain1 = 0;
2183 ti.freq1 = hz1209;
2184 ixj_init_tone(j, &ti);
2185 ti.tone_index = 11;
2186 ti.gain0 = 1;
2187 ti.freq0 = hz941;
2188 ti.gain1 = 0;
2189 ti.freq1 = hz1336;
2190 ixj_init_tone(j, &ti);
2191 ti.tone_index = 12;
2192 ti.gain0 = 1;
2193 ti.freq0 = hz941;
2194 ti.gain1 = 0;
2195 ti.freq1 = hz1477;
2196 ixj_init_tone(j, &ti);
2197 ti.tone_index = 13;
2198 ti.gain0 = 1;
2199 ti.freq0 = hz800;
2200 ti.gain1 = 0;
2201 ti.freq1 = 0;
2202 ixj_init_tone(j, &ti);
2203 ti.tone_index = 14;
2204 ti.gain0 = 1;
2205 ti.freq0 = hz1000;
2206 ti.gain1 = 0;
2207 ti.freq1 = 0;
2208 ixj_init_tone(j, &ti);
2209 ti.tone_index = 15;
2210 ti.gain0 = 1;
2211 ti.freq0 = hz1250;
2212 ti.gain1 = 0;
2213 ti.freq1 = 0;
2214 ixj_init_tone(j, &ti);
2215 ti.tone_index = 16;
2216 ti.gain0 = 1;
2217 ti.freq0 = hz950;
2218 ti.gain1 = 0;
2219 ti.freq1 = 0;
2220 ixj_init_tone(j, &ti);
2221 ti.tone_index = 17;
2222 ti.gain0 = 1;
2223 ti.freq0 = hz1100;
2224 ti.gain1 = 0;
2225 ti.freq1 = 0;
2226 ixj_init_tone(j, &ti);
2227 ti.tone_index = 18;
2228 ti.gain0 = 1;
2229 ti.freq0 = hz1400;
2230 ti.gain1 = 0;
2231 ti.freq1 = 0;
2232 ixj_init_tone(j, &ti);
2233 ti.tone_index = 19;
2234 ti.gain0 = 1;
2235 ti.freq0 = hz1500;
2236 ti.gain1 = 0;
2237 ti.freq1 = 0;
2238 ixj_init_tone(j, &ti);
2239 ti.tone_index = 20;
2240 ti.gain0 = 1;
2241 ti.freq0 = hz1600;
2242 ti.gain1 = 0;
2243 ti.freq1 = 0;
2244 ixj_init_tone(j, &ti);
2245 ti.tone_index = 21;
2246 ti.gain0 = 1;
2247 ti.freq0 = hz1800;
2248 ti.gain1 = 0;
2249 ti.freq1 = 0;
2250 ixj_init_tone(j, &ti);
2251 ti.tone_index = 22;
2252 ti.gain0 = 1;
2253 ti.freq0 = hz2100;
2254 ti.gain1 = 0;
2255 ti.freq1 = 0;
2256 ixj_init_tone(j, &ti);
2257 ti.tone_index = 23;
2258 ti.gain0 = 1;
2259 ti.freq0 = hz1300;
2260 ti.gain1 = 0;
2261 ti.freq1 = 0;
2262 ixj_init_tone(j, &ti);
2263 ti.tone_index = 24;
2264 ti.gain0 = 1;
2265 ti.freq0 = hz2450;
2266 ti.gain1 = 0;
2267 ti.freq1 = 0;
2268 ixj_init_tone(j, &ti);
2269 ti.tone_index = 25;
2270 ti.gain0 = 1;
2271 ti.freq0 = hz350;
2272 ti.gain1 = 0;
2273 ti.freq1 = hz440;
2274 ixj_init_tone(j, &ti);
2275 ti.tone_index = 26;
2276 ti.gain0 = 1;
2277 ti.freq0 = hz440;
2278 ti.gain1 = 0;
2279 ti.freq1 = hz480;
2280 ixj_init_tone(j, &ti);
2281 ti.tone_index = 27;
2282 ti.gain0 = 1;
2283 ti.freq0 = hz480;
2284 ti.gain1 = 0;
2285 ti.freq1 = hz620;
2286 ixj_init_tone(j, &ti);
2287
2288 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2289
2290 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2291
2292 j->ex.bits.dtmf_ready = 0;
2293 j->dtmf_state = 0;
2294 j->dtmf_wp = j->dtmf_rp = 0;
2295 j->rec_mode = j->play_mode = -1;
2296 j->flags.ringing = 0;
2297 j->maxrings = MAXRINGS;
2298 j->ring_cadence = USA_RING_CADENCE;
2299 if(j->cadence_f[5].enable) {
2300 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301 }
2302 j->drybuffer = 0;
2303 j->winktime = 320;
2304 j->flags.dtmf_oob = 0;
2305 for (cnt = 0; cnt < 4; cnt++)
2306 j->cadence_f[cnt].enable = 0;
2307
2308 idle(j);
2309
2310 if(j->cardtype == QTI_PHONECARD) {
2311 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312 }
2313
2314 if (file_p->f_mode & FMODE_READ)
2315 j->readers--;
2316 if (file_p->f_mode & FMODE_WRITE)
2317 j->writers--;
2318
2319 if (j->read_buffer && !j->readers) {
2320 kfree(j->read_buffer);
2321 j->read_buffer = NULL;
2322 j->read_buffer_size = 0;
2323 }
2324 if (j->write_buffer && !j->writers) {
2325 kfree(j->write_buffer);
2326 j->write_buffer = NULL;
2327 j->write_buffer_size = 0;
2328 }
2329 j->rec_codec = j->play_codec = 0;
2330 j->rec_frame_size = j->play_frame_size = 0;
2331 j->flags.cidsent = j->flags.cidring = 0;
2332
2333 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334 ixj_set_port(j, PORT_PSTN);
2335 daa_set_mode(j, SOP_PU_SLEEP);
2336 ixj_set_pots(j, 1);
2337 }
2338 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340 /* Set up the default signals for events */
2341 for (cnt = 0; cnt < 35; cnt++)
2342 j->ixj_signals[cnt] = SIGIO;
2343
2344 /* Set the excetion signal enable flags */
2345 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346 j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347 j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349 file_p->private_data = NULL;
2350 clear_bit(board, &j->busyflags);
2351 return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356 unsigned short fc, cnt, trg;
2357 int var;
2358
2359 trg = 0;
2360 if (ixj_WriteDSPCommand(0x5144, j)) {
2361 if(ixjdebug & 0x0001) {
2362 printk(KERN_INFO "Read Frame Counter failed!\n");
2363 }
2364 return -1;
2365 }
2366 fc = j->ssr.high << 8 | j->ssr.low;
2367 if (fc == j->frame_count)
2368 return 1;
2369
2370 j->frame_count = fc;
2371
2372 if (j->dtmf_proc)
2373 return 1;
2374
2375 var = 10;
2376
2377 for (cnt = 0; cnt < 4; cnt++) {
2378 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381 }
2382 return -1;
2383 }
2384 if (ixj_WriteDSPCommand(0x515C, j)) {
2385 if(ixjdebug & 0x0001) {
2386 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387 }
2388 return -1;
2389 }
2390 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392 if (j->cadence_f[cnt].enable) {
2393 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394 if (j->cadence_f[cnt].state == 0) {
2395 j->cadence_f[cnt].state = 1;
2396 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399 } else if (j->cadence_f[cnt].state == 2 &&
2400 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402 if (j->cadence_f[cnt].on2) {
2403 j->cadence_f[cnt].state = 3;
2404 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407 } else {
2408 j->cadence_f[cnt].state = 7;
2409 }
2410 } else if (j->cadence_f[cnt].state == 4 &&
2411 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413 if (j->cadence_f[cnt].on3) {
2414 j->cadence_f[cnt].state = 5;
2415 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418 } else {
2419 j->cadence_f[cnt].state = 7;
2420 }
2421 } else {
2422 j->cadence_f[cnt].state = 0;
2423 }
2424 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425 if (j->cadence_f[cnt].state == 1) {
2426 if(!j->cadence_f[cnt].on1) {
2427 j->cadence_f[cnt].state = 7;
2428 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430 if(j->cadence_f[cnt].off1) {
2431 j->cadence_f[cnt].state = 2;
2432 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435 } else {
2436 j->cadence_f[cnt].state = 7;
2437 }
2438 } else {
2439 j->cadence_f[cnt].state = 0;
2440 }
2441 } else if (j->cadence_f[cnt].state == 3) {
2442 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444 if(j->cadence_f[cnt].off2) {
2445 j->cadence_f[cnt].state = 4;
2446 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449 } else {
2450 j->cadence_f[cnt].state = 7;
2451 }
2452 } else {
2453 j->cadence_f[cnt].state = 0;
2454 }
2455 } else if (j->cadence_f[cnt].state == 5) {
2456 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458 if(j->cadence_f[cnt].off3) {
2459 j->cadence_f[cnt].state = 6;
2460 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463 } else {
2464 j->cadence_f[cnt].state = 7;
2465 }
2466 } else {
2467 j->cadence_f[cnt].state = 0;
2468 }
2469 } else {
2470 j->cadence_f[cnt].state = 0;
2471 }
2472 } else {
2473 switch(j->cadence_f[cnt].state) {
2474 case 1:
2475 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476 !j->cadence_f[cnt].off1 &&
2477 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479 j->cadence_f[cnt].state = 7;
2480 }
2481 break;
2482 case 3:
2483 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484 !j->cadence_f[cnt].off2 &&
2485 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486 j->cadence_f[cnt].state = 7;
2487 }
2488 break;
2489 case 5:
2490 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491 !j->cadence_f[cnt].off3) {
2492 j->cadence_f[cnt].state = 7;
2493 }
2494 break;
2495 }
2496 }
2497
2498 if (ixjdebug & 0x0040) {
2499 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500 switch(j->cadence_f[cnt].state) {
2501 case 0:
2502 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503 break;
2504 case 1:
2505 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507 break;
2508 case 2:
2509 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510 j->cadence_f[cnt].off1max);
2511 break;
2512 case 3:
2513 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514 j->cadence_f[cnt].on2max);
2515 break;
2516 case 4:
2517 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518 j->cadence_f[cnt].off2max);
2519 break;
2520 case 5:
2521 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522 j->cadence_f[cnt].on3max);
2523 break;
2524 case 6:
2525 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526 j->cadence_f[cnt].off3max);
2527 break;
2528 }
2529 }
2530 }
2531 if (j->cadence_f[cnt].state == 7) {
2532 j->cadence_f[cnt].state = 0;
2533 if (j->cadence_f[cnt].enable == 1)
2534 j->cadence_f[cnt].enable = 0;
2535 switch (cnt) {
2536 case 0:
2537 if(ixjdebug & 0x0020) {
2538 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539 }
2540 j->ex.bits.fc0 = 1;
2541 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542 break;
2543 case 1:
2544 if(ixjdebug & 0x0020) {
2545 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546 }
2547 j->ex.bits.fc1 = 1;
2548 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549 break;
2550 case 2:
2551 if(ixjdebug & 0x0020) {
2552 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553 }
2554 j->ex.bits.fc2 = 1;
2555 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556 break;
2557 case 3:
2558 if(ixjdebug & 0x0020) {
2559 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560 }
2561 j->ex.bits.fc3 = 1;
2562 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563 break;
2564 }
2565 }
2566 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569 trg = 1;
2570 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571 trg = 0;
2572 }
2573 switch (cnt) {
2574 case 0:
2575 if(ixjdebug & 0x0020) {
2576 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577 }
2578 j->ex.bits.f0 = 1;
2579 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580 break;
2581 case 1:
2582 if(ixjdebug & 0x0020) {
2583 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584 }
2585 j->ex.bits.f1 = 1;
2586 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587 break;
2588 case 2:
2589 if(ixjdebug & 0x0020) {
2590 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591 }
2592 j->ex.bits.f2 = 1;
2593 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594 break;
2595 case 3:
2596 if(ixjdebug & 0x0020) {
2597 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598 }
2599 j->ex.bits.f3 = 1;
2600 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601 break;
2602 }
2603 }
2604 }
2605 return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610 if (j->dtmf_proc) {
2611 return -1;
2612 }
2613 j->dtmf_proc = 1;
2614
2615 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2616 return -1;
2617
2618 j->dtmf.bytes.high = j->ssr.high;
2619 j->dtmf.bytes.low = j->ssr.low;
2620 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621 j->dtmf_state = 1;
2622 j->dtmf_current = j->dtmf.bits.digit;
2623 }
2624 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2625 {
2626 if(!j->cidcw_wait) {
2627 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628 j->dtmf_wp++;
2629 if (j->dtmf_wp == 79)
2630 j->dtmf_wp = 0;
2631 j->ex.bits.dtmf_ready = 1;
2632 if(j->ex_sig.bits.dtmf_ready) {
2633 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634 }
2635 }
2636 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637 if(ixjdebug & 0x0020) {
2638 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639 }
2640 j->flags.cidcw_ack = 1;
2641 }
2642 j->dtmf_state = 0;
2643 }
2644 j->dtmf_proc = 0;
2645
2646 return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657 static unsigned char table_ulaw2alaw[] =
2658 {
2659 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691 };
2692
2693 while (len--)
2694 {
2695 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696 buff++;
2697 }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702 static unsigned char table_alaw2ulaw[] =
2703 {
2704 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736 };
2737
2738 while (len--)
2739 {
2740 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741 buff++;
2742 }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747 unsigned long i = *ppos;
2748 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750 DECLARE_WAITQUEUE(wait, current);
2751
2752 if (j->flags.inread)
2753 return -EALREADY;
2754
2755 j->flags.inread = 1;
2756
2757 add_wait_queue(&j->read_q, &wait);
2758 set_current_state(TASK_INTERRUPTIBLE);
2759 mb();
2760
2761 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762 ++j->read_wait;
2763 if (file_p->f_flags & O_NONBLOCK) {
2764 set_current_state(TASK_RUNNING);
2765 remove_wait_queue(&j->read_q, &wait);
2766 j->flags.inread = 0;
2767 return -EAGAIN;
2768 }
2769 if (!ixj_hookstate(j)) {
2770 set_current_state(TASK_RUNNING);
2771 remove_wait_queue(&j->read_q, &wait);
2772 j->flags.inread = 0;
2773 return 0;
2774 }
2775 interruptible_sleep_on(&j->read_q);
2776 if (signal_pending(current)) {
2777 set_current_state(TASK_RUNNING);
2778 remove_wait_queue(&j->read_q, &wait);
2779 j->flags.inread = 0;
2780 return -EINTR;
2781 }
2782 }
2783
2784 remove_wait_queue(&j->read_q, &wait);
2785 set_current_state(TASK_RUNNING);
2786 /* Don't ever copy more than the user asks */
2787 if(j->rec_codec == ALAW)
2788 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790 j->read_buffer_ready = 0;
2791 if (i) {
2792 j->flags.inread = 0;
2793 return -EFAULT;
2794 } else {
2795 j->flags.inread = 0;
2796 return min(length, j->read_buffer_size);
2797 }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801 loff_t * ppos)
2802 {
2803 int pre_retval;
2804 ssize_t read_retval = 0;
2805 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807 pre_retval = ixj_PreRead(j, 0L);
2808 switch (pre_retval) {
2809 case NORMAL:
2810 read_retval = ixj_read(file_p, buf, length, ppos);
2811 ixj_PostRead(j, 0L);
2812 break;
2813 case NOPOST:
2814 read_retval = ixj_read(file_p, buf, length, ppos);
2815 break;
2816 case POSTONLY:
2817 ixj_PostRead(j, 0L);
2818 break;
2819 default:
2820 read_retval = pre_retval;
2821 }
2822 return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827 unsigned long i = *ppos;
2828 IXJ *j = file_p->private_data;
2829
2830 DECLARE_WAITQUEUE(wait, current);
2831
2832 if (j->flags.inwrite)
2833 return -EALREADY;
2834
2835 j->flags.inwrite = 1;
2836
2837 add_wait_queue(&j->write_q, &wait);
2838 set_current_state(TASK_INTERRUPTIBLE);
2839 mb();
2840
2841
2842 while (!j->write_buffers_empty) {
2843 ++j->write_wait;
2844 if (file_p->f_flags & O_NONBLOCK) {
2845 set_current_state(TASK_RUNNING);
2846 remove_wait_queue(&j->write_q, &wait);
2847 j->flags.inwrite = 0;
2848 return -EAGAIN;
2849 }
2850 if (!ixj_hookstate(j)) {
2851 set_current_state(TASK_RUNNING);
2852 remove_wait_queue(&j->write_q, &wait);
2853 j->flags.inwrite = 0;
2854 return 0;
2855 }
2856 interruptible_sleep_on(&j->write_q);
2857 if (signal_pending(current)) {
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 j->flags.inwrite = 0;
2861 return -EINTR;
2862 }
2863 }
2864 set_current_state(TASK_RUNNING);
2865 remove_wait_queue(&j->write_q, &wait);
2866 if (j->write_buffer_wp + count >= j->write_buffer_end)
2867 j->write_buffer_wp = j->write_buffer;
2868 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869 if (i) {
2870 j->flags.inwrite = 0;
2871 return -EFAULT;
2872 }
2873 if(j->play_codec == ALAW)
2874 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875 j->flags.inwrite = 0;
2876 return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881 int pre_retval;
2882 ssize_t write_retval = 0;
2883
2884 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886 pre_retval = ixj_PreWrite(j, 0L);
2887 switch (pre_retval) {
2888 case NORMAL:
2889 write_retval = ixj_write(file_p, buf, count, ppos);
2890 if (write_retval > 0) {
2891 ixj_PostWrite(j, 0L);
2892 j->write_buffer_wp += write_retval;
2893 j->write_buffers_empty--;
2894 }
2895 break;
2896 case NOPOST:
2897 write_retval = ixj_write(file_p, buf, count, ppos);
2898 if (write_retval > 0) {
2899 j->write_buffer_wp += write_retval;
2900 j->write_buffers_empty--;
2901 }
2902 break;
2903 case POSTONLY:
2904 ixj_PostWrite(j, 0L);
2905 break;
2906 default:
2907 write_retval = pre_retval;
2908 }
2909 return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914 int cnt, dly;
2915
2916 if (j->read_buffer) {
2917 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918 if (!(cnt % 16) && !IsRxReady(j)) {
2919 dly = 0;
2920 while (!IsRxReady(j)) {
2921 if (dly++ > 5) {
2922 dly = 0;
2923 break;
2924 }
2925 udelay(10);
2926 }
2927 }
2928 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930 inb_p(j->DSPbase + 0x0E);
2931 inb_p(j->DSPbase + 0x0F);
2932 }
2933 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935 }
2936 ++j->framesread;
2937 if (j->intercom != -1) {
2938 if (IsTxReady(get_ixj(j->intercom))) {
2939 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940 if (!(cnt % 16) && !IsTxReady(j)) {
2941 dly = 0;
2942 while (!IsTxReady(j)) {
2943 if (dly++ > 5) {
2944 dly = 0;
2945 break;
2946 }
2947 udelay(10);
2948 }
2949 }
2950 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952 }
2953 get_ixj(j->intercom)->frameswritten++;
2954 }
2955 } else {
2956 j->read_buffer_ready = 1;
2957 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2958
2959 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2960
2961 if(j->ixj_signals[SIG_READ_READY])
2962 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963 }
2964 }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969 {
2970 {
2971 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973 },
2974 {
2975 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977 },
2978 {
2979 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981 },
2982 {
2983 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985 },
2986 {
2987 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989 },
2990 {
2991 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993 }
2994 },
2995 {
2996 {
2997 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999 },
3000 {
3001 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003 },
3004 {
3005 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007 },
3008 {
3009 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011 },
3012 {
3013 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015 },
3016 {
3017 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019 }
3020 }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026 while (j->fskcnt < 20) {
3027 if(j->fskdcnt < (j->fsksize - 1))
3028 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030 j->fskcnt += 3;
3031 }
3032 j->fskcnt %= 20;
3033
3034 if (!bit)
3035 j->fskz++;
3036 if (j->fskz >= 6)
3037 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043 IXJ_CBYTE cb;
3044
3045 cb.cbyte = byte;
3046 ixj_write_cid_bit(j, 0);
3047 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060 int cnt;
3061
3062 for (cnt = 0; cnt < 150; cnt++) {
3063 ixj_write_cid_bit(j, 0);
3064 ixj_write_cid_bit(j, 1);
3065 }
3066 for (cnt = 0; cnt < 180; cnt++) {
3067 ixj_write_cid_bit(j, 1);
3068 }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073 int cnt;
3074
3075 for (cnt = 0; cnt < 80; cnt++) {
3076 ixj_write_cid_bit(j, 1);
3077 }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082 int cnt;
3083
3084 for (cnt = 0; cnt < strlen(s); cnt++) {
3085 ixj_write_cid_byte(j, s[cnt]);
3086 checksum = (checksum + s[cnt]);
3087 }
3088 return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093 int cnt;
3094
3095 for (cnt = 0; cnt < pad; cnt++) {
3096 if(j->fskdcnt < (j->fsksize - 1))
3097 j->fskdata[j->fskdcnt++] = 0x0000;
3098 }
3099 for (cnt = 0; cnt < 720; cnt++) {
3100 if(j->fskdcnt < (j->fsksize - 1))
3101 j->fskdata[j->fskdcnt++] = 0x0000;
3102 }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107 j->cid_play_codec = j->play_codec;
3108 j->cid_play_frame_size = j->play_frame_size;
3109 j->cid_play_volume = get_play_volume(j);
3110 j->cid_play_flag = j->flags.playing;
3111
3112 j->cid_rec_codec = j->rec_codec;
3113 j->cid_rec_volume = get_rec_volume(j);
3114 j->cid_rec_flag = j->flags.recording;
3115
3116 j->cid_play_aec_level = j->aec_level;
3117
3118 switch(j->baseframe.low) {
3119 case 0xA0:
3120 j->cid_base_frame_size = 20;
3121 break;
3122 case 0x50:
3123 j->cid_base_frame_size = 10;
3124 break;
3125 case 0xF0:
3126 j->cid_base_frame_size = 30;
3127 break;
3128 }
3129
3130 ixj_play_stop(j);
3131 ixj_cpt_stop(j);
3132
3133 j->flags.cidplay = 1;
3134
3135 set_base_frame(j, 30);
3136 set_play_codec(j, LINEAR16);
3137 set_play_volume(j, 0x1B);
3138 ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143 ixj_play_stop(j);
3144
3145 if(j->cidsize > 5000) {
3146 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147 }
3148 j->flags.cidplay = 0;
3149 if(ixjdebug & 0x0200) {
3150 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151 }
3152
3153 ixj_fsk_free(j);
3154
3155 j->fskdcnt = 0;
3156 set_base_frame(j, j->cid_base_frame_size);
3157 set_play_codec(j, j->cid_play_codec);
3158 ixj_aec_start(j, j->cid_play_aec_level);
3159 set_play_volume(j, j->cid_play_volume);
3160
3161 set_rec_codec(j, j->cid_rec_codec);
3162 set_rec_volume(j, j->cid_rec_volume);
3163
3164 if(j->cid_rec_flag)
3165 ixj_record_start(j);
3166
3167 if(j->cid_play_flag)
3168 ixj_play_start(j);
3169
3170 if(j->cid_play_flag) {
3171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3172 }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177 char sdmf1[50];
3178 char sdmf2[50];
3179 char sdmf3[80];
3180 char mdmflen, len1, len2, len3;
3181 int pad;
3182
3183 int checksum = 0;
3184
3185 if (j->dsp.low == 0x20 || j->flags.cidplay)
3186 return;
3187
3188 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189 j->cidsize = j->cidcnt = 0;
3190
3191 ixj_fsk_alloc(j);
3192
3193 strcpy(sdmf1, j->cid_send.month);
3194 strcat(sdmf1, j->cid_send.day);
3195 strcat(sdmf1, j->cid_send.hour);
3196 strcat(sdmf1, j->cid_send.min);
3197 strcpy(sdmf2, j->cid_send.number);
3198 strcpy(sdmf3, j->cid_send.name);
3199
3200 len1 = strlen(sdmf1);
3201 len2 = strlen(sdmf2);
3202 len3 = strlen(sdmf3);
3203 mdmflen = len1 + len2 + len3 + 6;
3204
3205 while(1){
3206 ixj_write_cid_seize(j);
3207
3208 ixj_write_cid_byte(j, 0x80);
3209 checksum = 0x80;
3210 ixj_write_cid_byte(j, mdmflen);
3211 checksum = checksum + mdmflen;
3212
3213 ixj_write_cid_byte(j, 0x01);
3214 checksum = checksum + 0x01;
3215 ixj_write_cid_byte(j, len1);
3216 checksum = checksum + len1;
3217 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218 if(ixj_hookstate(j) & 1)
3219 break;
3220
3221 ixj_write_cid_byte(j, 0x02);
3222 checksum = checksum + 0x02;
3223 ixj_write_cid_byte(j, len2);
3224 checksum = checksum + len2;
3225 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226 if(ixj_hookstate(j) & 1)
3227 break;
3228
3229 ixj_write_cid_byte(j, 0x07);
3230 checksum = checksum + 0x07;
3231 ixj_write_cid_byte(j, len3);
3232 checksum = checksum + len3;
3233 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234 if(ixj_hookstate(j) & 1)
3235 break;
3236
3237 checksum %= 256;
3238 checksum ^= 0xFF;
3239 checksum += 1;
3240
3241 ixj_write_cid_byte(j, (char) checksum);
3242
3243 pad = j->fskdcnt % 240;
3244 if (pad) {
3245 pad = 240 - pad;
3246 }
3247 ixj_pad_fsk(j, pad);
3248 break;
3249 }
3250
3251 ixj_write_frame(j);
3252 }
3253
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256 IXJ_TONE ti;
3257
3258 char sdmf1[50];
3259 char sdmf2[50];
3260 char sdmf3[80];
3261 char mdmflen, len1, len2, len3;
3262 int pad;
3263
3264 int checksum = 0;
3265
3266 if (j->dsp.low == 0x20 || j->flags.cidplay)
3267 return;
3268
3269 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270 j->cidsize = j->cidcnt = 0;
3271
3272 ixj_fsk_alloc(j);
3273
3274 j->flags.cidcw_ack = 0;
3275
3276 ti.tone_index = 23;
3277 ti.gain0 = 1;
3278 ti.freq0 = hz440;
3279 ti.gain1 = 0;
3280 ti.freq1 = 0;
3281 ixj_init_tone(j, &ti);
3282
3283 ixj_set_tone_on(1500, j);
3284 ixj_set_tone_off(32, j);
3285 if(ixjdebug & 0x0200) {
3286 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287 }
3288 ixj_play_tone(j, 23);
3289
3290 clear_bit(j->board, &j->busyflags);
3291 while(j->tone_state)
3292 schedule_timeout_interruptible(1);
3293 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294 schedule_timeout_interruptible(1);
3295 if(ixjdebug & 0x0200) {
3296 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297 }
3298
3299 ti.tone_index = 24;
3300 ti.gain0 = 1;
3301 ti.freq0 = hz2130;
3302 ti.gain1 = 0;
3303 ti.freq1 = hz2750;
3304 ixj_init_tone(j, &ti);
3305
3306 ixj_set_tone_off(10, j);
3307 ixj_set_tone_on(600, j);
3308 if(ixjdebug & 0x0200) {
3309 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310 }
3311 ixj_play_tone(j, 24);
3312
3313 clear_bit(j->board, &j->busyflags);
3314 while(j->tone_state)
3315 schedule_timeout_interruptible(1);
3316 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317 schedule_timeout_interruptible(1);
3318 if(ixjdebug & 0x0200) {
3319 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320 }
3321
3322 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324 clear_bit(j->board, &j->busyflags);
3325 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326 schedule_timeout_interruptible(1);
3327 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328 schedule_timeout_interruptible(1);
3329 j->cidcw_wait = 0;
3330 if(!j->flags.cidcw_ack) {
3331 if(ixjdebug & 0x0200) {
3332 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333 }
3334 ixj_post_cid(j);
3335 if(j->cid_play_flag) {
3336 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3337 }
3338 return;
3339 } else {
3340 ixj_pre_cid(j);
3341 }
3342 j->flags.cidcw_ack = 0;
3343 strcpy(sdmf1, j->cid_send.month);
3344 strcat(sdmf1, j->cid_send.day);
3345 strcat(sdmf1, j->cid_send.hour);
3346 strcat(sdmf1, j->cid_send.min);
3347 strcpy(sdmf2, j->cid_send.number);
3348 strcpy(sdmf3, j->cid_send.name);
3349
3350 len1 = strlen(sdmf1);
3351 len2 = strlen(sdmf2);
3352 len3 = strlen(sdmf3);
3353 mdmflen = len1 + len2 + len3 + 6;
3354
3355 ixj_write_cidcw_seize(j);
3356
3357 ixj_write_cid_byte(j, 0x80);
3358 checksum = 0x80;
3359 ixj_write_cid_byte(j, mdmflen);
3360 checksum = checksum + mdmflen;
3361
3362 ixj_write_cid_byte(j, 0x01);
3363 checksum = checksum + 0x01;
3364 ixj_write_cid_byte(j, len1);
3365 checksum = checksum + len1;
3366 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368 ixj_write_cid_byte(j, 0x02);
3369 checksum = checksum + 0x02;
3370 ixj_write_cid_byte(j, len2);
3371 checksum = checksum + len2;
3372 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374 ixj_write_cid_byte(j, 0x07);
3375 checksum = checksum + 0x07;
3376 ixj_write_cid_byte(j, len3);
3377 checksum = checksum + len3;
3378 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380 checksum %= 256;
3381 checksum ^= 0xFF;
3382 checksum += 1;
3383
3384 ixj_write_cid_byte(j, (char) checksum);
3385
3386 pad = j->fskdcnt % 240;
3387 if (pad) {
3388 pad = 240 - pad;
3389 }
3390 ixj_pad_fsk(j, pad);
3391 if(ixjdebug & 0x0200) {
3392 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393 }
3394 }
3395
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398 char mdmflen;
3399 int pad;
3400
3401 int checksum = 0;
3402
3403 if (j->dsp.low == 0x20 || j->flags.cidplay)
3404 return;
3405
3406 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407 j->cidsize = j->cidcnt = 0;
3408
3409 ixj_fsk_alloc(j);
3410
3411 mdmflen = 3;
3412
3413 if (j->port == PORT_POTS)
3414 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416 ixj_write_cid_seize(j);
3417
3418 ixj_write_cid_byte(j, 0x82);
3419 checksum = 0x82;
3420 ixj_write_cid_byte(j, mdmflen);
3421 checksum = checksum + mdmflen;
3422
3423 ixj_write_cid_byte(j, 0x0B);
3424 checksum = checksum + 0x0B;
3425 ixj_write_cid_byte(j, 1);
3426 checksum = checksum + 1;
3427
3428 if(msg) {
3429 ixj_write_cid_byte(j, 0xFF);
3430 checksum = checksum + 0xFF;
3431 }
3432 else {
3433 ixj_write_cid_byte(j, 0x00);
3434 checksum = checksum + 0x00;
3435 }
3436
3437 checksum %= 256;
3438 checksum ^= 0xFF;
3439 checksum += 1;
3440
3441 ixj_write_cid_byte(j, (char) checksum);
3442
3443 pad = j->fskdcnt % 240;
3444 if (pad) {
3445 pad = 240 - pad;
3446 }
3447 ixj_pad_fsk(j, pad);
3448 }
3449
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452 int cnt, frame_count, dly;
3453 IXJ_WORD dat;
3454
3455 frame_count = 0;
3456 if(j->flags.cidplay) {
3457 for(cnt = 0; cnt < 480; cnt++) {
3458 if (!(cnt % 16) && !IsTxReady(j)) {
3459 dly = 0;
3460 while (!IsTxReady(j)) {
3461 if (dly++ > 5) {
3462 dly = 0;
3463 break;
3464 }
3465 udelay(10);
3466 }
3467 }
3468 dat.word = j->fskdata[j->cidcnt++];
3469 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471 cnt++;
3472 }
3473 if(j->cidcnt >= j->fskdcnt) {
3474 ixj_post_cid(j);
3475 }
3476 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477 and there is real audio data in the buffer, we need to throw it away because
3478 we just used it's time slot */
3479 if (j->write_buffer_rp > j->write_buffer_wp) {
3480 j->write_buffer_rp += j->cid_play_frame_size * 2;
3481 if (j->write_buffer_rp >= j->write_buffer_end) {
3482 j->write_buffer_rp = j->write_buffer;
3483 }
3484 j->write_buffers_empty++;
3485 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3486
3487 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3488 }
3489 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490 if (j->write_buffer_wp > j->write_buffer_rp) {
3491 frame_count =
3492 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493 }
3494 if (j->write_buffer_rp > j->write_buffer_wp) {
3495 frame_count =
3496 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498 }
3499 if (frame_count >= 1) {
3500 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501 BYTES blankword;
3502
3503 switch (j->play_mode) {
3504 case PLAYBACK_MODE_ULAW:
3505 case PLAYBACK_MODE_ALAW:
3506 blankword.low = blankword.high = 0xFF;
3507 break;
3508 case PLAYBACK_MODE_8LINEAR:
3509 case PLAYBACK_MODE_16LINEAR:
3510 default:
3511 blankword.low = blankword.high = 0x00;
3512 break;
3513 case PLAYBACK_MODE_8LINEAR_WSS:
3514 blankword.low = blankword.high = 0x80;
3515 break;
3516 }
3517 for (cnt = 0; cnt < 16; cnt++) {
3518 if (!(cnt % 16) && !IsTxReady(j)) {
3519 dly = 0;
3520 while (!IsTxReady(j)) {
3521 if (dly++ > 5) {
3522 dly = 0;
3523 break;
3524 }
3525 udelay(10);
3526 }
3527 }
3528 outb_p((blankword.low), j->DSPbase + 0x0C);
3529 outb_p((blankword.high), j->DSPbase + 0x0D);
3530 }
3531 j->flags.play_first_frame = 0;
3532 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533 for (cnt = 0; cnt < 24; cnt++) {
3534 BYTES blankword;
3535
3536 if(cnt == 12) {
3537 blankword.low = 0x02;
3538 blankword.high = 0x00;
3539 }
3540 else {
3541 blankword.low = blankword.high = 0x00;
3542 }
3543 if (!(cnt % 16) && !IsTxReady(j)) {
3544 dly = 0;
3545 while (!IsTxReady(j)) {
3546 if (dly++ > 5) {
3547 dly = 0;
3548 break;
3549 }
3550 udelay(10);
3551 }
3552 }
3553 outb_p((blankword.low), j->DSPbase + 0x0C);
3554 outb_p((blankword.high), j->DSPbase + 0x0D);
3555 }
3556 j->flags.play_first_frame = 0;
3557 }
3558 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559 if (!(cnt % 16) && !IsTxReady(j)) {
3560 dly = 0;
3561 while (!IsTxReady(j)) {
3562 if (dly++ > 5) {
3563 dly = 0;
3564 break;
3565 }
3566 udelay(10);
3567 }
3568 }
3569 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3570 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571 if (j->write_buffer_rp[cnt] == 0 &&
3572 j->write_buffer_rp[cnt + 1] == 0 &&
3573 j->write_buffer_rp[cnt + 2] == 0 &&
3574 j->write_buffer_rp[cnt + 3] == 0 &&
3575 j->write_buffer_rp[cnt + 4] == 0 &&
3576 j->write_buffer_rp[cnt + 5] == 0 &&
3577 j->write_buffer_rp[cnt + 6] == 0 &&
3578 j->write_buffer_rp[cnt + 7] == 0 &&
3579 j->write_buffer_rp[cnt + 8] == 0 &&
3580 j->write_buffer_rp[cnt + 9] == 0) {
3581 /* someone is trying to write silence lets make this a type 0 frame. */
3582 outb_p(0x00, j->DSPbase + 0x0C);
3583 outb_p(0x00, j->DSPbase + 0x0D);
3584 } else {
3585 /* so all other frames are type 1. */
3586 outb_p(0x01, j->DSPbase + 0x0C);
3587 outb_p(0x00, j->DSPbase + 0x0D);
3588 }
3589 }
3590 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592 *(j->write_buffer_rp + cnt) = 0;
3593 *(j->write_buffer_rp + cnt + 1) = 0;
3594 }
3595 j->write_buffer_rp += j->play_frame_size * 2;
3596 if (j->write_buffer_rp >= j->write_buffer_end) {
3597 j->write_buffer_rp = j->write_buffer;
3598 }
3599 j->write_buffers_empty++;
3600 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3601
3602 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3603
3604 ++j->frameswritten;
3605 }
3606 } else {
3607 j->drybuffer++;
3608 }
3609 if(j->ixj_signals[SIG_WRITE_READY]) {
3610 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611 }
3612 }
3613
3614 static int idle(IXJ *j)
3615 {
3616 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3617
3618 return 0;
3619
3620 if (j->ssr.high || j->ssr.low) {
3621 return 0;
3622 } else {
3623 j->play_mode = -1;
3624 j->flags.playing = 0;
3625 j->rec_mode = -1;
3626 j->flags.recording = 0;
3627 return 1;
3628 }
3629 }
3630
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633 unsigned short cmd;
3634 int cnt;
3635
3636 idle(j);
3637 j->cid_play_aec_level = j->aec_level;
3638 aec_stop(j);
3639 for (cnt = 0; cnt < 10; cnt++) {
3640 if (idle(j))
3641 break;
3642 }
3643 if (j->ssr.high || j->ssr.low)
3644 return -1;
3645 if (j->dsp.low != 0x20) {
3646 switch (size) {
3647 case 30:
3648 cmd = 0x07F0;
3649 /* Set Base Frame Size to 240 pg9-10 8021 */
3650 break;
3651 case 20:
3652 cmd = 0x07A0;
3653 /* Set Base Frame Size to 160 pg9-10 8021 */
3654 break;
3655 case 10:
3656 cmd = 0x0750;
3657 /* Set Base Frame Size to 80 pg9-10 8021 */
3658 break;
3659 default:
3660 return -1;
3661 }
3662 } else {
3663 if (size == 30)
3664 return size;
3665 else
3666 return -1;
3667 }
3668 if (ixj_WriteDSPCommand(cmd, j)) {
3669 j->baseframe.high = j->baseframe.low = 0xFF;
3670 return -1;
3671 } else {
3672 j->baseframe.high = j->ssr.high;
3673 j->baseframe.low = j->ssr.low;
3674 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676 return -1;
3677 }
3678 }
3679 ixj_aec_start(j, j->cid_play_aec_level);
3680 return size;
3681 }
3682
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685 int retval = 0;
3686
3687 j->rec_codec = rate;
3688
3689 switch (rate) {
3690 case G723_63:
3691 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692 j->rec_frame_size = 12;
3693 j->rec_mode = 0;
3694 } else {
3695 retval = 1;
3696 }
3697 break;
3698 case G723_53:
3699 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700 j->rec_frame_size = 10;
3701 j->rec_mode = 0;
3702 } else {
3703 retval = 1;
3704 }
3705 break;
3706 case TS85:
3707 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708 j->rec_frame_size = 16;
3709 j->rec_mode = 0;
3710 } else {
3711 retval = 1;
3712 }
3713 break;
3714 case TS48:
3715 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716 j->rec_frame_size = 9;
3717 j->rec_mode = 0;
3718 } else {
3719 retval = 1;
3720 }
3721 break;
3722 case TS41:
3723 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724 j->rec_frame_size = 8;
3725 j->rec_mode = 0;
3726 } else {
3727 retval = 1;
3728 }
3729 break;
3730 case G728:
3731 if (j->dsp.low != 0x20) {
3732 j->rec_frame_size = 48;
3733 j->rec_mode = 0;
3734 } else {
3735 retval = 1;
3736 }
3737 break;
3738 case G729:
3739 if (j->dsp.low != 0x20) {
3740 if (!j->flags.g729_loaded) {
3741 retval = 1;
3742 break;
3743 }
3744 switch (j->baseframe.low) {
3745 case 0xA0:
3746 j->rec_frame_size = 10;
3747 break;
3748 case 0x50:
3749 j->rec_frame_size = 5;
3750 break;
3751 default:
3752 j->rec_frame_size = 15;
3753 break;
3754 }
3755 j->rec_mode = 0;
3756 } else {
3757 retval = 1;
3758 }
3759 break;
3760 case G729B:
3761 if (j->dsp.low != 0x20) {
3762 if (!j->flags.g729_loaded) {
3763 retval = 1;
3764 break;
3765 }
3766 switch (j->baseframe.low) {
3767 case 0xA0:
3768 j->rec_frame_size = 12;
3769 break;
3770 case 0x50:
3771 j->rec_frame_size = 6;
3772 break;
3773 default:
3774 j->rec_frame_size = 18;
3775 break;
3776 }
3777 j->rec_mode = 0;
3778 } else {
3779 retval = 1;
3780 }
3781 break;
3782 case ULAW:
3783 switch (j->baseframe.low) {
3784 case 0xA0:
3785 j->rec_frame_size = 80;
3786 break;
3787 case 0x50:
3788 j->rec_frame_size = 40;
3789 break;
3790 default:
3791 j->rec_frame_size = 120;
3792 break;
3793 }
3794 j->rec_mode = 4;
3795 break;
3796 case ALAW:
3797 switch (j->baseframe.low) {
3798 case 0xA0:
3799 j->rec_frame_size = 80;
3800 break;
3801 case 0x50:
3802 j->rec_frame_size = 40;
3803 break;
3804 default:
3805 j->rec_frame_size = 120;
3806 break;
3807 }
3808 j->rec_mode = 4;
3809 break;
3810 case LINEAR16:
3811 switch (j->baseframe.low) {
3812 case 0xA0:
3813 j->rec_frame_size = 160;
3814 break;
3815 case 0x50:
3816 j->rec_frame_size = 80;
3817 break;
3818 default:
3819 j->rec_frame_size = 240;
3820 break;
3821 }
3822 j->rec_mode = 5;
3823 break;
3824 case LINEAR8:
3825 switch (j->baseframe.low) {
3826 case 0xA0:
3827 j->rec_frame_size = 80;
3828 break;
3829 case 0x50:
3830 j->rec_frame_size = 40;
3831 break;
3832 default:
3833 j->rec_frame_size = 120;
3834 break;
3835 }
3836 j->rec_mode = 6;
3837 break;
3838 case WSS:
3839 switch (j->baseframe.low) {
3840 case 0xA0:
3841 j->rec_frame_size = 80;
3842 break;
3843 case 0x50:
3844 j->rec_frame_size = 40;
3845 break;
3846 default:
3847 j->rec_frame_size = 120;
3848 break;
3849 }
3850 j->rec_mode = 7;
3851 break;
3852 default:
3853 kfree(j->read_buffer);
3854 j->rec_frame_size = 0;
3855 j->rec_mode = -1;
3856 j->read_buffer = NULL;
3857 j->read_buffer_size = 0;
3858 retval = 1;
3859 break;
3860 }
3861 return retval;
3862 }
3863
3864 static int ixj_record_start(IXJ *j)
3865 {
3866 unsigned short cmd = 0x0000;
3867
3868 if (j->read_buffer) {
3869 ixj_record_stop(j);
3870 }
3871 j->flags.recording = 1;
3872 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874 if(ixjdebug & 0x0002)
3875 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877 if (!j->rec_mode) {
3878 switch (j->rec_codec) {
3879 case G723_63:
3880 cmd = 0x5131;
3881 break;
3882 case G723_53:
3883 cmd = 0x5132;
3884 break;
3885 case TS85:
3886 cmd = 0x5130; /* TrueSpeech 8.5 */
3887
3888 break;
3889 case TS48:
3890 cmd = 0x5133; /* TrueSpeech 4.8 */
3891
3892 break;
3893 case TS41:
3894 cmd = 0x5134; /* TrueSpeech 4.1 */
3895
3896 break;
3897 case G728:
3898 cmd = 0x5135;
3899 break;
3900 case G729:
3901 case G729B:
3902 cmd = 0x5136;
3903 break;
3904 default:
3905 return 1;
3906 }
3907 if (ixj_WriteDSPCommand(cmd, j))
3908 return -1;
3909 }
3910 if (!j->read_buffer) {
3911 if (!j->read_buffer)
3912 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913 if (!j->read_buffer) {
3914 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915 return -ENOMEM;
3916 }
3917 }
3918 j->read_buffer_size = j->rec_frame_size * 2;
3919
3920 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3921
3922 return -1;
3923
3924 switch (j->rec_mode) {
3925 case 0:
3926 cmd = 0x1C03; /* Record C1 */
3927
3928 break;
3929 case 4:
3930 if (j->ver.low == 0x12) {
3931 cmd = 0x1E03; /* Record C1 */
3932
3933 } else {
3934 cmd = 0x1E01; /* Record C1 */
3935
3936 }
3937 break;
3938 case 5:
3939 if (j->ver.low == 0x12) {
3940 cmd = 0x1E83; /* Record C1 */
3941
3942 } else {
3943 cmd = 0x1E81; /* Record C1 */
3944
3945 }
3946 break;
3947 case 6:
3948 if (j->ver.low == 0x12) {
3949 cmd = 0x1F03; /* Record C1 */
3950
3951 } else {
3952 cmd = 0x1F01; /* Record C1 */
3953
3954 }
3955 break;
3956 case 7:
3957 if (j->ver.low == 0x12) {
3958 cmd = 0x1F83; /* Record C1 */
3959 } else {
3960 cmd = 0x1F81; /* Record C1 */
3961 }
3962 break;
3963 }
3964 if (ixj_WriteDSPCommand(cmd, j))
3965 return -1;
3966
3967 if (j->flags.playing) {
3968 ixj_aec_start(j, j->aec_level);
3969 }
3970 return 0;
3971 }
3972
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975 if (ixjdebug & 0x0002)
3976 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978 kfree(j->read_buffer);
3979 j->read_buffer = NULL;
3980 j->read_buffer_size = 0;
3981 if (j->rec_mode > -1) {
3982 ixj_WriteDSPCommand(0x5120, j);
3983 j->rec_mode = -1;
3984 }
3985 j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989 if (arg)
3990 ixj_WriteDSPCommand(0x513F, j);
3991 else
3992 ixj_WriteDSPCommand(0x513E, j);
3993 }
3994
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997 if (depth > 60)
3998 depth = 60;
3999 if (depth < 0)
4000 depth = 0;
4001 ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006 ixj_WriteDSPCommand(0xCF07, j);
4007 ixj_WriteDSPCommand(volume, j);
4008 }
4009
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012 ixj_WriteDSPCommand(0xCF05, j);
4013 return j->ssr.high << 8 | j->ssr.low;
4014 }
4015
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018 if(j->aec_level == AEC_AGC) {
4019 if (ixjdebug & 0x0002)
4020 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021 ixj_WriteDSPCommand(0xCF96, j);
4022 ixj_WriteDSPCommand(volume, j);
4023 } else {
4024 if (ixjdebug & 0x0002)
4025 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026 ixj_WriteDSPCommand(0xCF03, j);
4027 ixj_WriteDSPCommand(volume, j);
4028 }
4029 }
4030
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033 int newvolume, dsprecmax;
4034
4035 if (ixjdebug & 0x0002)
4036 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037 if(volume > 100 || volume < 0) {
4038 return -1;
4039 }
4040
4041 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042 switch (j->cardtype) {
4043 case QTI_PHONEJACK:
4044 dsprecmax = 0x440;
4045 break;
4046 case QTI_LINEJACK:
4047 dsprecmax = 0x180;
4048 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4049 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4050 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4051 break;
4052 case QTI_PHONEJACK_LITE:
4053 dsprecmax = 0x4C0;
4054 break;
4055 case QTI_PHONEJACK_PCI:
4056 dsprecmax = 0x100;
4057 break;
4058 case QTI_PHONECARD:
4059 dsprecmax = 0x400;
4060 break;
4061 default:
4062 return -1;
4063 }
4064 newvolume = (dsprecmax * volume) / 100;
4065 set_rec_volume(j, newvolume);
4066 return 0;
4067 }
4068
4069 static int get_rec_volume(IXJ *j)
4070 {
4071 if(j->aec_level == AEC_AGC) {
4072 if (ixjdebug & 0x0002)
4073 printk(KERN_INFO "Getting AGC Threshold\n");
4074 ixj_WriteDSPCommand(0xCF86, j);
4075 if (ixjdebug & 0x0002)
4076 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077 return j->ssr.high << 8 | j->ssr.low;
4078 } else {
4079 if (ixjdebug & 0x0002)
4080 printk(KERN_INFO "Getting Record Volume\n");
4081 ixj_WriteDSPCommand(0xCF01, j);
4082 return j->ssr.high << 8 | j->ssr.low;
4083 }
4084 }
4085
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088 int volume, newvolume, dsprecmax;
4089
4090 switch (j->cardtype) {
4091 case QTI_PHONEJACK:
4092 dsprecmax = 0x440;
4093 break;
4094 case QTI_LINEJACK:
4095 dsprecmax = 0x180;
4096 break;
4097 case QTI_PHONEJACK_LITE:
4098 dsprecmax = 0x4C0;
4099 break;
4100 case QTI_PHONEJACK_PCI:
4101 dsprecmax = 0x100;
4102 break;
4103 case QTI_PHONECARD:
4104 dsprecmax = 0x400;
4105 break;
4106 default:
4107 return -1;
4108 }
4109 volume = get_rec_volume(j);
4110 newvolume = (volume * 100) / dsprecmax;
4111 if(newvolume > 100)
4112 newvolume = 100;
4113 return newvolume;
4114 }
4115
4116 static int get_rec_level(IXJ *j)
4117 {
4118 int retval;
4119
4120 ixj_WriteDSPCommand(0xCF88, j);
4121
4122 retval = j->ssr.high << 8 | j->ssr.low;
4123 retval = (retval * 256) / 240;
4124 return retval;
4125 }
4126
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129 j->aec_level = level;
4130 if (ixjdebug & 0x0002)
4131 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132 if (!level) {
4133 aec_stop(j);
4134 } else {
4135 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138 ixj_WriteDSPCommand(0x0300, j);
4139 }
4140 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144 switch (level) {
4145 case AEC_LOW:
4146 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148 ixj_WriteDSPCommand(0xE011, j);
4149 ixj_WriteDSPCommand(0xFFFF, j);
4150
4151 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152 ixj_WriteDSPCommand(0x0000, j); /* to off */
4153
4154 break;
4155
4156 case AEC_MED:
4157 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159 ixj_WriteDSPCommand(0xE011, j);
4160 ixj_WriteDSPCommand(0x0080, j);
4161
4162 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163 ixj_WriteDSPCommand(0x0000, j); /* to off */
4164
4165 break;
4166
4167 case AEC_HIGH:
4168 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170 ixj_WriteDSPCommand(0xE011, j);
4171 ixj_WriteDSPCommand(0x0080, j);
4172
4173 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174 ixj_WriteDSPCommand(0x0000, j); /* to off */
4175
4176 break;
4177
4178 case AEC_AGC:
4179 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182 ixj_WriteDSPCommand(0xE011, j);
4183 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188 ixj_WriteDSPCommand(0x0224, j);
4189 else
4190 ixj_WriteDSPCommand(0x1224, j);
4191
4192 ixj_WriteDSPCommand(0xE014, j);
4193 ixj_WriteDSPCommand(0x0003, j); /* Lock 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 Minumum gain */
4199 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220 ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222 break;
4223
4224 case AEC_AUTO:
4225 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227 ixj_WriteDSPCommand(0xE011, j);
4228 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233 ixj_WriteDSPCommand(0x0224, j);
4234 else
4235 ixj_WriteDSPCommand(0x1224, j);
4236
4237 ixj_WriteDSPCommand(0xE014, j);
4238 ixj_WriteDSPCommand(0x0003, j); /* Lock 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 retval = ixj_init_filter(j, &jf);
6584 break;
6585 case IXJCTL_SET_FILTER_RAW:
6586 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6587 retval = -EFAULT;
6588 else
6589 retval = ixj_init_filter_raw(j, &jfr);
6590 break;
6591 case IXJCTL_GET_FILTER_HIST:
6592 if(arg<0||arg>3)
6593 retval = -EINVAL;
6594 else
6595 retval = j->filter_hist[arg];
6596 break;
6597 case IXJCTL_INIT_TONE:
6598 if (copy_from_user(&ti, argp, sizeof(ti)))
6599 retval = -EFAULT;
6600 else
6601 retval = ixj_init_tone(j, &ti);
6602 break;
6603 case IXJCTL_TONE_CADENCE:
6604 retval = ixj_build_cadence(j, argp);
6605 break;
6606 case IXJCTL_FILTER_CADENCE:
6607 retval = ixj_build_filter_cadence(j, argp);
6608 break;
6609 case IXJCTL_SIGCTL:
6610 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6611 retval = -EFAULT;
6612 break;
6613 }
6614 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6615 if(j->sigdef.event < 33) {
6616 raise = 1;
6617 for(mant = 0; mant < j->sigdef.event; mant++){
6618 raise *= 2;
6619 }
6620 if(j->sigdef.signal)
6621 j->ex_sig.bytes |= raise;
6622 else
6623 j->ex_sig.bytes &= (raise^0xffff);
6624 }
6625 break;
6626 case IXJCTL_INTERCOM_STOP:
6627 if(arg < 0 || arg >= IXJMAX)
6628 return -EINVAL;
6629 j->intercom = -1;
6630 ixj_record_stop(j);
6631 ixj_play_stop(j);
6632 idle(j);
6633 get_ixj(arg)->intercom = -1;
6634 ixj_record_stop(get_ixj(arg));
6635 ixj_play_stop(get_ixj(arg));
6636 idle(get_ixj(arg));
6637 break;
6638 case IXJCTL_INTERCOM_START:
6639 if(arg < 0 || arg >= IXJMAX)
6640 return -EINVAL;
6641 j->intercom = arg;
6642 ixj_record_start(j);
6643 ixj_play_start(j);
6644 get_ixj(arg)->intercom = board;
6645 ixj_play_start(get_ixj(arg));
6646 ixj_record_start(get_ixj(arg));
6647 break;
6648 }
6649 if (ixjdebug & 0x0040)
6650 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6651 clear_bit(board, &j->busyflags);
6652 return retval;
6653 }
6654
6655 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6656 {
6657 long ret;
6658 mutex_lock(&ixj_mutex);
6659 ret = do_ixj_ioctl(file_p, cmd, arg);
6660 mutex_unlock(&ixj_mutex);
6661 return ret;
6662 }
6663
6664 static int ixj_fasync(int fd, struct file *file_p, int mode)
6665 {
6666 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6667
6668 return fasync_helper(fd, file_p, mode, &j->async_queue);
6669 }
6670
6671 static const struct file_operations ixj_fops =
6672 {
6673 .owner = THIS_MODULE,
6674 .read = ixj_enhanced_read,
6675 .write = ixj_enhanced_write,
6676 .poll = ixj_poll,
6677 .unlocked_ioctl = ixj_ioctl,
6678 .release = ixj_release,
6679 .fasync = ixj_fasync,
6680 .llseek = default_llseek,
6681 };
6682
6683 static int ixj_linetest(IXJ *j)
6684 {
6685 j->flags.pstncheck = 1; /* Testing */
6686 j->flags.pstn_present = 0; /* Assume the line is not there */
6687
6688 daa_int_read(j); /*Clear DAA Interrupt flags */
6689 /* */
6690 /* Hold all relays in the normally de-energized position. */
6691 /* */
6692
6693 j->pld_slicw.bits.rly1 = 0;
6694 j->pld_slicw.bits.rly2 = 0;
6695 j->pld_slicw.bits.rly3 = 0;
6696 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6697 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6698
6699 outb_p(j->pld_scrw.byte, j->XILINXbase);
6700 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6701 if (j->pld_slicr.bits.potspstn) {
6702 j->flags.pots_pstn = 1;
6703 j->flags.pots_correct = 0;
6704 LED_SetState(0x4, j);
6705 } else {
6706 j->flags.pots_pstn = 0;
6707 j->pld_slicw.bits.rly1 = 0;
6708 j->pld_slicw.bits.rly2 = 0;
6709 j->pld_slicw.bits.rly3 = 1;
6710 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6711 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6712
6713 outb_p(j->pld_scrw.byte, j->XILINXbase);
6714 daa_set_mode(j, SOP_PU_CONVERSATION);
6715 msleep(1000);
6716 daa_int_read(j);
6717 daa_set_mode(j, SOP_PU_RESET);
6718 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6719 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6720 LED_SetState(0x4, j);
6721 j->pld_slicw.bits.rly3 = 0;
6722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6723 } else {
6724 j->flags.pots_correct = 1;
6725 LED_SetState(0x8, j);
6726 j->pld_slicw.bits.rly1 = 1;
6727 j->pld_slicw.bits.rly2 = 0;
6728 j->pld_slicw.bits.rly3 = 0;
6729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6730 }
6731 }
6732 j->pld_slicw.bits.rly3 = 0;
6733 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6734 daa_set_mode(j, SOP_PU_CONVERSATION);
6735 msleep(1000);
6736 daa_int_read(j);
6737 daa_set_mode(j, SOP_PU_RESET);
6738 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6739 j->pstn_sleeptil = jiffies + (hertz / 4);
6740 j->flags.pstn_present = 1;
6741 } else {
6742 j->flags.pstn_present = 0;
6743 }
6744 if (j->flags.pstn_present) {
6745 if (j->flags.pots_correct) {
6746 LED_SetState(0xA, j);
6747 } else {
6748 LED_SetState(0x6, j);
6749 }
6750 } else {
6751 if (j->flags.pots_correct) {
6752 LED_SetState(0x9, j);
6753 } else {
6754 LED_SetState(0x5, j);
6755 }
6756 }
6757 j->flags.pstncheck = 0; /* Testing */
6758 return j->flags.pstn_present;
6759 }
6760
6761 static int ixj_selfprobe(IXJ *j)
6762 {
6763 unsigned short cmd;
6764 int cnt;
6765 BYTES bytes;
6766
6767 init_waitqueue_head(&j->poll_q);
6768 init_waitqueue_head(&j->read_q);
6769 init_waitqueue_head(&j->write_q);
6770
6771 while(atomic_read(&j->DSPWrite) > 0)
6772 atomic_dec(&j->DSPWrite);
6773 if (ixjdebug & 0x0002)
6774 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6775 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6776
6777 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6778 return -1;
6779 /* The read values of the SSR should be 0x00 for the IDLE command */
6780 if (j->ssr.low || j->ssr.high)
6781 return -1;
6782 if (ixjdebug & 0x0002)
6783 printk(KERN_INFO "Get Device ID Code\n");
6784 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6785 return -1;
6786 j->dsp.low = j->ssr.low;
6787 j->dsp.high = j->ssr.high;
6788 if (ixjdebug & 0x0002)
6789 printk(KERN_INFO "Get Device Version Code\n");
6790 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6791 return -1;
6792 j->ver.low = j->ssr.low;
6793 j->ver.high = j->ssr.high;
6794 if (!j->cardtype) {
6795 if (j->dsp.low == 0x21) {
6796 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6797 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6798 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6799 bytes.low = inb_p(j->XILINXbase + 0x02);
6800 if (bytes.low == bytes.high) /* Register is read only on */
6801 /* Internet PhoneJack Lite */
6802 {
6803 j->cardtype = QTI_PHONEJACK_LITE;
6804 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6805 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6806 return -1;
6807 }
6808 j->pld_slicw.pcib.e1 = 1;
6809 outb_p(j->pld_slicw.byte, j->XILINXbase);
6810 } else {
6811 j->cardtype = QTI_LINEJACK;
6812
6813 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6814 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6815 return -1;
6816 }
6817 }
6818 } else if (j->dsp.low == 0x22) {
6819 j->cardtype = QTI_PHONEJACK_PCI;
6820 request_region(j->XILINXbase, 4, "ixj control");
6821 j->pld_slicw.pcib.e1 = 1;
6822 outb_p(j->pld_slicw.byte, j->XILINXbase);
6823 } else
6824 j->cardtype = QTI_PHONEJACK;
6825 } else {
6826 switch (j->cardtype) {
6827 case QTI_PHONEJACK:
6828 if (!j->dsp.low != 0x20) {
6829 j->dsp.high = 0x80;
6830 j->dsp.low = 0x20;
6831 ixj_WriteDSPCommand(0x3800, j);
6832 j->ver.low = j->ssr.low;
6833 j->ver.high = j->ssr.high;
6834 }
6835 break;
6836 case QTI_LINEJACK:
6837 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6838 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6839 return -1;
6840 }
6841 break;
6842 case QTI_PHONEJACK_LITE:
6843 case QTI_PHONEJACK_PCI:
6844 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6845 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6846 return -1;
6847 }
6848 j->pld_slicw.pcib.e1 = 1;
6849 outb_p(j->pld_slicw.byte, j->XILINXbase);
6850 break;
6851 case QTI_PHONECARD:
6852 break;
6853 }
6854 }
6855 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6856 if (ixjdebug & 0x0002)
6857 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6858 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6859 return -1;
6860 if (ixjdebug & 0x0002)
6861 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6862 if (j->cardtype == QTI_PHONEJACK) {
6863 cmd = 0x9FF2;
6864 } else {
6865 cmd = 0x9FF5;
6866 }
6867 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6868 return -1;
6869 } else {
6870 if (set_base_frame(j, 30) != 30)
6871 return -1;
6872 if (ixjdebug & 0x0002)
6873 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6874 if (j->cardtype == QTI_PHONECARD) {
6875 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6876 return -1;
6877 }
6878 if (j->cardtype == QTI_LINEJACK) {
6879 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6880 return -1;
6881 if (ixjdebug & 0x0002)
6882 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6883 j->pld_clock.byte = 0;
6884 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6885 }
6886 }
6887
6888 if (j->dsp.low == 0x20) {
6889 if (ixjdebug & 0x0002)
6890 printk(KERN_INFO "Configure GPIO pins\n");
6891 j->gpio.bytes.high = 0x09;
6892 /* bytes.low = 0xEF; 0xF7 */
6893 j->gpio.bits.gpio1 = 1;
6894 j->gpio.bits.gpio2 = 1;
6895 j->gpio.bits.gpio3 = 0;
6896 j->gpio.bits.gpio4 = 1;
6897 j->gpio.bits.gpio5 = 1;
6898 j->gpio.bits.gpio6 = 1;
6899 j->gpio.bits.gpio7 = 1;
6900 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6901 if (ixjdebug & 0x0002)
6902 printk(KERN_INFO "Enable SLIC\n");
6903 j->gpio.bytes.high = 0x0B;
6904 j->gpio.bytes.low = 0x00;
6905 j->gpio.bits.gpio1 = 0;
6906 j->gpio.bits.gpio2 = 1;
6907 j->gpio.bits.gpio5 = 0;
6908 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6909 j->port = PORT_POTS;
6910 } else {
6911 if (j->cardtype == QTI_LINEJACK) {
6912 LED_SetState(0x1, j);
6913 msleep(100);
6914 LED_SetState(0x2, j);
6915 msleep(100);
6916 LED_SetState(0x4, j);
6917 msleep(100);
6918 LED_SetState(0x8, j);
6919 msleep(100);
6920 LED_SetState(0x0, j);
6921 daa_get_version(j);
6922 if (ixjdebug & 0x0002)
6923 printk("Loading DAA Coefficients\n");
6924 DAA_Coeff_US(j);
6925 if (!ixj_daa_write(j)) {
6926 printk("DAA write failed on board %d\n", j->board);
6927 return -1;
6928 }
6929 if(!ixj_daa_cid_reset(j)) {
6930 printk("DAA CID reset failed on board %d\n", j->board);
6931 return -1;
6932 }
6933 j->flags.pots_correct = 0;
6934 j->flags.pstn_present = 0;
6935 ixj_linetest(j);
6936 if (j->flags.pots_correct) {
6937 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6938
6939 outb_p(j->pld_scrw.byte, j->XILINXbase);
6940 j->pld_slicw.bits.rly1 = 1;
6941 j->pld_slicw.bits.spken = 1;
6942 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6943 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6944 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6945 j->port = PORT_POTS;
6946 }
6947 ixj_set_port(j, PORT_PSTN);
6948 ixj_set_pots(j, 1);
6949 if (ixjdebug & 0x0002)
6950 printk(KERN_INFO "Enable Mixer\n");
6951 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6952 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6953
6954 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6955 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6956
6957 ixj_mixer(0x0480, j); /*FM Left mute */
6958 ixj_mixer(0x0580, j); /*FM Right mute */
6959
6960 ixj_mixer(0x0680, j); /*CD Left mute */
6961 ixj_mixer(0x0780, j); /*CD Right mute */
6962
6963 ixj_mixer(0x0880, j); /*Line Left mute */
6964 ixj_mixer(0x0980, j); /*Line Right mute */
6965
6966 ixj_mixer(0x0A80, j); /*Aux left mute */
6967 ixj_mixer(0x0B80, j); /*Aux right mute */
6968
6969 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6970 ixj_mixer(0x0D80, j); /*Mono2 mute */
6971
6972 ixj_mixer(0x0E80, j); /*Mic mute */
6973
6974 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6975
6976 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6977 ixj_mixer(0x110C, j);
6978
6979
6980 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6981 ixj_mixer(0x1401, j);
6982
6983 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6984 ixj_mixer(0x1501, j);
6985
6986 ixj_mixer(0x1700, j); /*Clock select */
6987
6988 ixj_mixer(0x1800, j); /*ADC input from mixer */
6989
6990 ixj_mixer(0x1901, j); /*Mic gain 30db */
6991
6992 if (ixjdebug & 0x0002)
6993 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6994 j->cadence_f[4].state = 0;
6995 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6996 j->cadence_f[4].off1 = 0;
6997 j->cadence_f[4].on2 = 0;
6998 j->cadence_f[4].off2 = 0;
6999 j->cadence_f[4].on3 = 0;
7000 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7001 j->pstn_last_rmr = jiffies;
7002
7003 } else {
7004 if (j->cardtype == QTI_PHONECARD) {
7005 ixj_WriteDSPCommand(0xCF07, j);
7006 ixj_WriteDSPCommand(0x00B0, j);
7007 ixj_set_port(j, PORT_SPEAKER);
7008 } else {
7009 ixj_set_port(j, PORT_POTS);
7010 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7011 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7012 }
7013 }
7014 }
7015
7016 j->intercom = -1;
7017 j->framesread = j->frameswritten = 0;
7018 j->read_wait = j->write_wait = 0;
7019 j->rxreadycheck = j->txreadycheck = 0;
7020
7021 /* initialise the DTMF prescale to a sensible value */
7022 if (j->cardtype == QTI_LINEJACK) {
7023 set_dtmf_prescale(j, 0x10);
7024 } else {
7025 set_dtmf_prescale(j, 0x40);
7026 }
7027 set_play_volume(j, 0x100);
7028 set_rec_volume(j, 0x100);
7029
7030 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7031 return -1;
7032 /* The read values of the SSR should be 0x00 for the IDLE command */
7033 if (j->ssr.low || j->ssr.high)
7034 return -1;
7035
7036 if (ixjdebug & 0x0002)
7037 printk(KERN_INFO "Enable Line Monitor\n");
7038
7039 if (ixjdebug & 0x0002)
7040 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7041
7042 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7043 return -1;
7044
7045 if (ixjdebug & 0x002)
7046 printk(KERN_INFO "Enable DTMF Detectors\n");
7047
7048 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7049 return -1;
7050
7051 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7052 return -1;
7053
7054 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7055
7056 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7057
7058 j->ex.bits.dtmf_ready = 0;
7059 j->dtmf_state = 0;
7060 j->dtmf_wp = j->dtmf_rp = 0;
7061 j->rec_mode = j->play_mode = -1;
7062 j->flags.ringing = 0;
7063 j->maxrings = MAXRINGS;
7064 j->ring_cadence = USA_RING_CADENCE;
7065 j->drybuffer = 0;
7066 j->winktime = 320;
7067 j->flags.dtmf_oob = 0;
7068 for (cnt = 0; cnt < 4; cnt++)
7069 j->cadence_f[cnt].enable = 0;
7070 /* must be a device on the specified address */
7071 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7072
7073 /* Set up the default signals for events */
7074 for (cnt = 0; cnt < 35; cnt++)
7075 j->ixj_signals[cnt] = SIGIO;
7076
7077 /* Set the excetion signal enable flags */
7078 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7079 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 =
7080 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;
7081 #ifdef IXJ_DYN_ALLOC
7082 j->fskdata = NULL;
7083 #endif
7084 j->fskdcnt = 0;
7085 j->cidcw_wait = 0;
7086
7087 /* Register with the Telephony for Linux subsystem */
7088 j->p.f_op = &ixj_fops;
7089 j->p.open = ixj_open;
7090 j->p.board = j->board;
7091 phone_register_device(&j->p, PHONE_UNIT_ANY);
7092
7093 ixj_init_timer(j);
7094 ixj_add_timer(j);
7095 return 0;
7096 }
7097
7098 /*
7099 * Exported service for pcmcia card handling
7100 */
7101
7102 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7103 {
7104 IXJ *j = ixj_alloc();
7105
7106 j->board = 0;
7107
7108 j->DSPbase = dsp;
7109 j->XILINXbase = xilinx;
7110 j->cardtype = QTI_PHONECARD;
7111 ixj_selfprobe(j);
7112 return j;
7113 }
7114
7115 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7116
7117 static int ixj_get_status_proc(char *buf)
7118 {
7119 int len;
7120 int cnt;
7121 IXJ *j;
7122 len = 0;
7123 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7124 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7125 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7126 len += sprintf(buf + len, "\nUsing old telephony API");
7127 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7128
7129 for (cnt = 0; cnt < IXJMAX; cnt++) {
7130 j = get_ixj(cnt);
7131 if(j==NULL)
7132 continue;
7133 if (j->DSPbase) {
7134 len += sprintf(buf + len, "\nCard Num %d", cnt);
7135 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7136 if (j->cardtype != QTI_PHONEJACK)
7137 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7138 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7139 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7140 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7141 switch (j->cardtype) {
7142 case (QTI_PHONEJACK):
7143 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7144 break;
7145 case (QTI_LINEJACK):
7146 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7147 if (j->flags.g729_loaded)
7148 len += sprintf(buf + len, " w/G.729 A/B");
7149 len += sprintf(buf + len, " Country = %d", j->daa_country);
7150 break;
7151 case (QTI_PHONEJACK_LITE):
7152 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7153 if (j->flags.g729_loaded)
7154 len += sprintf(buf + len, " w/G.729 A/B");
7155 break;
7156 case (QTI_PHONEJACK_PCI):
7157 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7158 if (j->flags.g729_loaded)
7159 len += sprintf(buf + len, " w/G.729 A/B");
7160 break;
7161 case (QTI_PHONECARD):
7162 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7163 if (j->flags.g729_loaded)
7164 len += sprintf(buf + len, " w/G.729 A/B");
7165 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7166 if (!j->pccr1.bits.drf)
7167 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7168 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7169 break;
7170 default:
7171 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7172 break;
7173 }
7174 len += sprintf(buf + len, "\nReaders %d", j->readers);
7175 len += sprintf(buf + len, "\nWriters %d", j->writers);
7176 add_caps(j);
7177 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7178 if (j->dsp.low != 0x20)
7179 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7180 if (j->flags.cidsent)
7181 len += sprintf(buf + len, "\nCaller ID data sent");
7182 else
7183 len += sprintf(buf + len, "\nCaller ID data not sent");
7184
7185 len += sprintf(buf + len, "\nPlay CODEC ");
7186 switch (j->play_codec) {
7187 case G723_63:
7188 len += sprintf(buf + len, "G.723.1 6.3");
7189 break;
7190 case G723_53:
7191 len += sprintf(buf + len, "G.723.1 5.3");
7192 break;
7193 case TS85:
7194 len += sprintf(buf + len, "TrueSpeech 8.5");
7195 break;
7196 case TS48:
7197 len += sprintf(buf + len, "TrueSpeech 4.8");
7198 break;
7199 case TS41:
7200 len += sprintf(buf + len, "TrueSpeech 4.1");
7201 break;
7202 case G728:
7203 len += sprintf(buf + len, "G.728");
7204 break;
7205 case G729:
7206 len += sprintf(buf + len, "G.729");
7207 break;
7208 case G729B:
7209 len += sprintf(buf + len, "G.729B");
7210 break;
7211 case ULAW:
7212 len += sprintf(buf + len, "uLaw");
7213 break;
7214 case ALAW:
7215 len += sprintf(buf + len, "aLaw");
7216 break;
7217 case LINEAR16:
7218 len += sprintf(buf + len, "16 bit Linear");
7219 break;
7220 case LINEAR8:
7221 len += sprintf(buf + len, "8 bit Linear");
7222 break;
7223 case WSS:
7224 len += sprintf(buf + len, "Windows Sound System");
7225 break;
7226 default:
7227 len += sprintf(buf + len, "NO CODEC CHOSEN");
7228 break;
7229 }
7230 len += sprintf(buf + len, "\nRecord CODEC ");
7231 switch (j->rec_codec) {
7232 case G723_63:
7233 len += sprintf(buf + len, "G.723.1 6.3");
7234 break;
7235 case G723_53:
7236 len += sprintf(buf + len, "G.723.1 5.3");
7237 break;
7238 case TS85:
7239 len += sprintf(buf + len, "TrueSpeech 8.5");
7240 break;
7241 case TS48:
7242 len += sprintf(buf + len, "TrueSpeech 4.8");
7243 break;
7244 case TS41:
7245 len += sprintf(buf + len, "TrueSpeech 4.1");
7246 break;
7247 case G728:
7248 len += sprintf(buf + len, "G.728");
7249 break;
7250 case G729:
7251 len += sprintf(buf + len, "G.729");
7252 break;
7253 case G729B:
7254 len += sprintf(buf + len, "G.729B");
7255 break;
7256 case ULAW:
7257 len += sprintf(buf + len, "uLaw");
7258 break;
7259 case ALAW:
7260 len += sprintf(buf + len, "aLaw");
7261 break;
7262 case LINEAR16:
7263 len += sprintf(buf + len, "16 bit Linear");
7264 break;
7265 case LINEAR8:
7266 len += sprintf(buf + len, "8 bit Linear");
7267 break;
7268 case WSS:
7269 len += sprintf(buf + len, "Windows Sound System");
7270 break;
7271 default:
7272 len += sprintf(buf + len, "NO CODEC CHOSEN");
7273 break;
7274 }
7275 len += sprintf(buf + len, "\nAEC ");
7276 switch (j->aec_level) {
7277 case AEC_OFF:
7278 len += sprintf(buf + len, "Off");
7279 break;
7280 case AEC_LOW:
7281 len += sprintf(buf + len, "Low");
7282 break;
7283 case AEC_MED:
7284 len += sprintf(buf + len, "Med");
7285 break;
7286 case AEC_HIGH:
7287 len += sprintf(buf + len, "High");
7288 break;
7289 case AEC_AUTO:
7290 len += sprintf(buf + len, "Auto");
7291 break;
7292 case AEC_AGC:
7293 len += sprintf(buf + len, "AEC/AGC");
7294 break;
7295 default:
7296 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7297 break;
7298 }
7299
7300 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7301 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7302 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7303
7304 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7305
7306 if (j->cardtype == QTI_LINEJACK) {
7307 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7308 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7309 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7310 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7311 switch (j->daa_mode) {
7312 case SOP_PU_SLEEP:
7313 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7314 break;
7315 case SOP_PU_RINGING:
7316 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7317 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7318 break;
7319 case SOP_PU_CONVERSATION:
7320 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7321 break;
7322 case SOP_PU_PULSEDIALING:
7323 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7324 break;
7325 }
7326 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7327 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7328 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7329 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7330 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7331 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7332 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7333 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7334 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7335 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7336 }
7337 switch (j->port) {
7338 case PORT_POTS:
7339 len += sprintf(buf + len, "\nPort POTS");
7340 break;
7341 case PORT_PSTN:
7342 len += sprintf(buf + len, "\nPort PSTN");
7343 break;
7344 case PORT_SPEAKER:
7345 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7346 break;
7347 case PORT_HANDSET:
7348 len += sprintf(buf + len, "\nPort HANDSET");
7349 break;
7350 }
7351 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7352 len += sprintf(buf + len, "\nSLIC state ");
7353 switch (SLIC_GetState(j)) {
7354 case PLD_SLIC_STATE_OC:
7355 len += sprintf(buf + len, "OC");
7356 break;
7357 case PLD_SLIC_STATE_RINGING:
7358 len += sprintf(buf + len, "RINGING");
7359 break;
7360 case PLD_SLIC_STATE_ACTIVE:
7361 len += sprintf(buf + len, "ACTIVE");
7362 break;
7363 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7364 len += sprintf(buf + len, "OHT");
7365 break;
7366 case PLD_SLIC_STATE_TIPOPEN:
7367 len += sprintf(buf + len, "TIPOPEN");
7368 break;
7369 case PLD_SLIC_STATE_STANDBY:
7370 len += sprintf(buf + len, "STANDBY");
7371 break;
7372 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7373 len += sprintf(buf + len, "APR");
7374 break;
7375 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7376 len += sprintf(buf + len, "OHTPR");
7377 break;
7378 default:
7379 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7380 break;
7381 }
7382 }
7383 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7384 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7385 #ifdef PERFMON_STATS
7386 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7387 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7388 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7389 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7390 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7391 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7392 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7393 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7394 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7395 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7396 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7397 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7398 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7399 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7400
7401 #endif
7402 len += sprintf(buf + len, "\n");
7403 }
7404 }
7405 return len;
7406 }
7407
7408 static int ixj_read_proc(char *page, char **start, off_t off,
7409 int count, int *eof, void *data)
7410 {
7411 int len = ixj_get_status_proc(page);
7412 if (len <= off+count) *eof = 1;
7413 *start = page + off;
7414 len -= off;
7415 if (len>count) len = count;
7416 if (len<0) len = 0;
7417 return len;
7418 }
7419
7420
7421 static void cleanup(void)
7422 {
7423 int cnt;
7424 IXJ *j;
7425
7426 for (cnt = 0; cnt < IXJMAX; cnt++) {
7427 j = get_ixj(cnt);
7428 if(j != NULL && j->DSPbase) {
7429 if (ixjdebug & 0x0002)
7430 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7431 del_timer(&j->timer);
7432 if (j->cardtype == QTI_LINEJACK) {
7433 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7434
7435 outb_p(j->pld_scrw.byte, j->XILINXbase);
7436 j->pld_slicw.bits.rly1 = 0;
7437 j->pld_slicw.bits.rly2 = 0;
7438 j->pld_slicw.bits.rly3 = 0;
7439 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7440 LED_SetState(0x0, j);
7441 if (ixjdebug & 0x0002)
7442 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7443 release_region(j->XILINXbase, 8);
7444 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7445 if (ixjdebug & 0x0002)
7446 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7447 release_region(j->XILINXbase, 4);
7448 }
7449 kfree(j->read_buffer);
7450 kfree(j->write_buffer);
7451 if (j->dev)
7452 pnp_device_detach(j->dev);
7453 if (ixjdebug & 0x0002)
7454 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7455 phone_unregister_device(&j->p);
7456 if (ixjdebug & 0x0002)
7457 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7458 release_region(j->DSPbase, 16);
7459 #ifdef IXJ_DYN_ALLOC
7460 if (ixjdebug & 0x0002)
7461 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7462 kfree(j);
7463 ixj[cnt] = NULL;
7464 #endif
7465 }
7466 }
7467 if (ixjdebug & 0x0002)
7468 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7469 remove_proc_entry ("ixj", NULL);
7470 }
7471
7472 /* Typedefs */
7473 typedef struct {
7474 BYTE length;
7475 DWORD bits;
7476 } DATABLOCK;
7477
7478 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7479 {
7480 lastLCC = lastLCC & 0xfb;
7481 lastLCC = lastLCC | (byData ? 4 : 0);
7482 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7483
7484 mdelay(1);
7485 lastLCC = lastLCC | 0x01;
7486 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7487
7488 byData = byData << 1;
7489 lastLCC = lastLCC & 0xfe;
7490 mdelay(1);
7491 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7492
7493 }
7494
7495 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7496 {
7497 mdelay(1);
7498 lastLCC = lastLCC | 0x01;
7499 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7500
7501 lastLCC = lastLCC & 0xfe;
7502 mdelay(1);
7503 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7504
7505 return ((inb(wEEPROMAddress) >> 3) & 1);
7506 }
7507
7508 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7509 {
7510 BYTE lastLCC;
7511 WORD wEEPROMAddress = wAddress + 3;
7512 DWORD i;
7513 BYTE byResult;
7514 *pwResult = 0;
7515 lastLCC = inb(wEEPROMAddress);
7516 lastLCC = lastLCC | 0x02;
7517 lastLCC = lastLCC & 0xfe;
7518 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7519
7520 mdelay(1); /* delay */
7521
7522 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7523 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7524 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7525 for (i = 0; i < 8; i++) {
7526 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7527 wLoc <<= 1;
7528 }
7529
7530 for (i = 0; i < 16; i++) {
7531 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7532 *pwResult = (*pwResult << 1) | byResult;
7533 }
7534
7535 mdelay(1); /* another delay */
7536
7537 lastLCC = lastLCC & 0xfd;
7538 outb(lastLCC, wEEPROMAddress); /* negate CS */
7539
7540 return 0;
7541 }
7542
7543 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7544 {
7545 WORD wLo, wHi;
7546 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7547 return 0;
7548 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7549 return 0;
7550 return (((DWORD) wHi << 16) | wLo);
7551 }
7552
7553 static int dspio[IXJMAX + 1] =
7554 {
7555 0,
7556 };
7557 static int xio[IXJMAX + 1] =
7558 {
7559 0,
7560 };
7561
7562 module_param_array(dspio, int, NULL, 0);
7563 module_param_array(xio, int, NULL, 0);
7564 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7565 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7566 MODULE_LICENSE("GPL");
7567
7568 static void __exit ixj_exit(void)
7569 {
7570 cleanup();
7571 }
7572
7573 static IXJ *new_ixj(unsigned long port)
7574 {
7575 IXJ *res;
7576 if (!request_region(port, 16, "ixj DSP")) {
7577 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7578 return NULL;
7579 }
7580 res = ixj_alloc();
7581 if (!res) {
7582 release_region(port, 16);
7583 printk(KERN_INFO "ixj: out of memory\n");
7584 return NULL;
7585 }
7586 res->DSPbase = port;
7587 return res;
7588 }
7589
7590 static int __init ixj_probe_isapnp(int *cnt)
7591 {
7592 int probe = 0;
7593 int func = 0x110;
7594 struct pnp_dev *dev = NULL, *old_dev = NULL;
7595
7596 while (1) {
7597 do {
7598 IXJ *j;
7599 int result;
7600
7601 old_dev = dev;
7602 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7603 ISAPNP_FUNCTION(func), old_dev);
7604 if (!dev || !dev->card)
7605 break;
7606 result = pnp_device_attach(dev);
7607 if (result < 0) {
7608 printk("pnp attach failed %d \n", result);
7609 break;
7610 }
7611 if (pnp_activate_dev(dev) < 0) {
7612 printk("pnp activate failed (out of resources?)\n");
7613 pnp_device_detach(dev);
7614 return -ENOMEM;
7615 }
7616
7617 if (!pnp_port_valid(dev, 0)) {
7618 pnp_device_detach(dev);
7619 return -ENODEV;
7620 }
7621
7622 j = new_ixj(pnp_port_start(dev, 0));
7623 if (!j)
7624 break;
7625
7626 if (func != 0x110)
7627 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7628
7629 switch (func) {
7630 case (0x110):
7631 j->cardtype = QTI_PHONEJACK;
7632 break;
7633 case (0x310):
7634 j->cardtype = QTI_LINEJACK;
7635 break;
7636 case (0x410):
7637 j->cardtype = QTI_PHONEJACK_LITE;
7638 break;
7639 }
7640 j->board = *cnt;
7641 probe = ixj_selfprobe(j);
7642 if(!probe) {
7643 j->serial = dev->card->serial;
7644 j->dev = dev;
7645 switch (func) {
7646 case 0x110:
7647 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7648 break;
7649 case 0x310:
7650 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7651 break;
7652 case 0x410:
7653 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7654 break;
7655 }
7656 }
7657 ++*cnt;
7658 } while (dev);
7659 if (func == 0x410)
7660 break;
7661 if (func == 0x310)
7662 func = 0x410;
7663 if (func == 0x110)
7664 func = 0x310;
7665 dev = NULL;
7666 }
7667 return probe;
7668 }
7669
7670 static int __init ixj_probe_isa(int *cnt)
7671 {
7672 int i, probe;
7673
7674 /* Use passed parameters for older kernels without PnP */
7675 for (i = 0; i < IXJMAX; i++) {
7676 if (dspio[i]) {
7677 IXJ *j = new_ixj(dspio[i]);
7678
7679 if (!j)
7680 break;
7681
7682 j->XILINXbase = xio[i];
7683 j->cardtype = 0;
7684
7685 j->board = *cnt;
7686 probe = ixj_selfprobe(j);
7687 j->dev = NULL;
7688 ++*cnt;
7689 }
7690 }
7691 return 0;
7692 }
7693
7694 static int __init ixj_probe_pci(int *cnt)
7695 {
7696 struct pci_dev *pci = NULL;
7697 int i, probe = 0;
7698 IXJ *j = NULL;
7699
7700 for (i = 0; i < IXJMAX - *cnt; i++) {
7701 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7702 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7703 if (!pci)
7704 break;
7705
7706 if (pci_enable_device(pci))
7707 break;
7708 j = new_ixj(pci_resource_start(pci, 0));
7709 if (!j)
7710 break;
7711
7712 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7713 j->XILINXbase = j->DSPbase + 0x10;
7714 j->cardtype = QTI_PHONEJACK_PCI;
7715 j->board = *cnt;
7716 probe = ixj_selfprobe(j);
7717 if (!probe)
7718 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7719 ++*cnt;
7720 }
7721 pci_dev_put(pci);
7722 return probe;
7723 }
7724
7725 static int __init ixj_init(void)
7726 {
7727 int cnt = 0;
7728 int probe = 0;
7729
7730 cnt = 0;
7731
7732 /* These might be no-ops, see above. */
7733 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7734 return probe;
7735 }
7736 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7737 return probe;
7738 }
7739 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7740 return probe;
7741 }
7742 printk(KERN_INFO "ixj driver initialized.\n");
7743 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7744 return probe;
7745 }
7746
7747 module_init(ixj_init);
7748 module_exit(ixj_exit);
7749
7750 static void DAA_Coeff_US(IXJ *j)
7751 {
7752 int i;
7753
7754 j->daa_country = DAA_US;
7755 /*----------------------------------------------- */
7756 /* CAO */
7757 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7758 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7759 }
7760
7761 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7762 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7770 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7778 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7779 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7780 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7788 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7796 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7797 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7798 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7799 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7800 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7801 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7802 /* Bytes for AR-filter (09): 52,D3,11,42 */
7803 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7804 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7805 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7806 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7807 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7816 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7825 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7833 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7834 /* ; (10K, 0.68uF) */
7835 /* */
7836 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7837 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7845 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7853 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7854
7855 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7856 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7857 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7858 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7859 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7860
7861 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7862 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7863 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7864 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7865 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7866 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7867 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7868 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7869 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7870 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7871 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7872 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7876 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7877 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7878 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7879 /* */
7880 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7881 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7884 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7885
7886 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7887 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7895 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7903 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7904 /* */
7905 /* ;CR Registers */
7906 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7907 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7908 /* Config. Reg. 1 (dialing) (cr1):05 */
7909 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7910 /* Config. Reg. 2 (caller ID) (cr2):04 */
7911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7912 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7914 /* Config. Reg. 4 (analog gain) (cr4):02 */
7915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7916 /* Config. Reg. 5 (Version) (cr5):02 */
7917 /* Config. Reg. 6 (Reserved) (cr6):00 */
7918 /* Config. Reg. 7 (Reserved) (cr7):00 */
7919 /* */
7920 /* ;xr Registers */
7921 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7922
7923 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7924 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7925
7926 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7927 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7928 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7929 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7930 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7931 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7932
7933 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7934 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7935 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7936 /* Ext. Reg. 6 (Power State) (xr6):00 */
7937 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7938 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7939 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7940 /* */
7941 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7942 /* 12,33,5A,C3 ; 770 Hz */
7943 /* 13,3C,5B,32 ; 852 Hz */
7944 /* 1D,1B,5C,CC ; 941 Hz */
7945
7946 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7947 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7950 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7951 /* EC,1D,52,22 ; 1336 Hz */
7952 /* AA,AC,51,D2 ; 1477 Hz */
7953 /* 9B,3B,51,25 ; 1633 Hz */
7954 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7957 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7958 }
7959
7960 static void DAA_Coeff_UK(IXJ *j)
7961 {
7962 int i;
7963
7964 j->daa_country = DAA_UK;
7965 /*----------------------------------------------- */
7966 /* CAO */
7967 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7968 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7969 }
7970
7971 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7972 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7980 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7988 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7989 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7990 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7998 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8006 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8007 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8008 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8009 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8010 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8011 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8012 /* Bytes for AR-filter (09): E2,27,10,D6 */
8013 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8014 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8015 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8016 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8017 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8018 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8026 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8035 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8043 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8044 /* ; idle */
8045 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8046 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8054 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8062 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8063 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8064 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8065 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8066 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8067 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8068 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8069 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8077 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8085 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8086 /* ;CR Registers */
8087 /* Config. Reg. 0 (filters) (cr0):FF */
8088 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8089 /* Config. Reg. 1 (dialing) (cr1):05 */
8090 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8091 /* Config. Reg. 2 (caller ID) (cr2):04 */
8092 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8093 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8094 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8095 /* Config. Reg. 4 (analog gain) (cr4):02 */
8096 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8097 /* Config. Reg. 5 (Version) (cr5):02 */
8098 /* Config. Reg. 6 (Reserved) (cr6):00 */
8099 /* Config. Reg. 7 (Reserved) (cr7):00 */
8100 /* ;xr Registers */
8101 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8102
8103 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8104 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8105
8106 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8107 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8108
8109 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8110 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8111 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8112 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8113 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8114 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8115 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8116 /* Ext. Reg. 6 (Power State) (xr6):00 */
8117 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8118 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8119 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8120 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8121 /* 12,33,5A,C3 ; 770 Hz */
8122 /* 13,3C,5B,32 ; 852 Hz */
8123 /* 1D,1B,5C,CC ; 941 Hz */
8124
8125 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8126 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8129 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8130 /* EC,1D,52,22 ; 1336 Hz */
8131 /* AA,AC,51,D2 ; 1477 Hz */
8132 /* 9B,3B,51,25 ; 1633 Hz */
8133 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8136 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8137 }
8138
8139
8140 static void DAA_Coeff_France(IXJ *j)
8141 {
8142 int i;
8143
8144 j->daa_country = DAA_FRANCE;
8145 /*----------------------------------------------- */
8146 /* CAO */
8147 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8148 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8149 }
8150
8151 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8152 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8160 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8168 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8169 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8170 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8178 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8186 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8187 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8188 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8189 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8190 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8191 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8192 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8193 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8194 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8195 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8196 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8197 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8198 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8206 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8215 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8223 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8224 /* ; idle */
8225 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8226 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8234 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8242 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8243 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8244 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8245 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8246 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8247 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8248 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8249 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8257 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8265 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8266 /* ;CR Registers */
8267 /* Config. Reg. 0 (filters) (cr0):FF */
8268 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8269 /* Config. Reg. 1 (dialing) (cr1):05 */
8270 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8271 /* Config. Reg. 2 (caller ID) (cr2):04 */
8272 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8273 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8274 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8275 /* Config. Reg. 4 (analog gain) (cr4):02 */
8276 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8277 /* Config. Reg. 5 (Version) (cr5):02 */
8278 /* Config. Reg. 6 (Reserved) (cr6):00 */
8279 /* Config. Reg. 7 (Reserved) (cr7):00 */
8280 /* ;xr Registers */
8281 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8282
8283 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8284 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8285
8286 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8287 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8288
8289 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8290 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8291 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8292 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8293 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8294 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8295 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8296 /* Ext. Reg. 6 (Power State) (xr6):00 */
8297 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8298 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8299 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8300 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8301 /* 12,33,5A,C3 ; 770 Hz */
8302 /* 13,3C,5B,32 ; 852 Hz */
8303 /* 1D,1B,5C,CC ; 941 Hz */
8304
8305 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8306 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8309 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8310 /* EC,1D,52,22 ; 1336 Hz */
8311 /* AA,AC,51,D2 ; 1477 Hz */
8312 /* 9B,3B,51,25 ; 1633 Hz */
8313 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8316 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8317 }
8318
8319
8320 static void DAA_Coeff_Germany(IXJ *j)
8321 {
8322 int i;
8323
8324 j->daa_country = DAA_GERMANY;
8325 /*----------------------------------------------- */
8326 /* CAO */
8327 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8328 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8329 }
8330
8331 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8332 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8340 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8348 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8349 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8350 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8358 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8366 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8367 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8368 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8369 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8370 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8371 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8372 /* Bytes for AR-filter (09): 72,42,13,4B */
8373 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8374 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8375 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8376 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8377 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8378 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8386 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8395 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8403 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8404 /* ; (10K, 0.68uF) */
8405 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8406 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8414 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8422 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8423 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8424 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8425 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8426 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8427 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8428 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8429 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8437 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8445 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8446 /* ;CR Registers */
8447 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8448 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8449 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8450 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8451 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8452 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8453 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8454 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8455 /* Config. Reg. 4 (analog gain) (cr4):02 */
8456 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8457 /* Config. Reg. 5 (Version) (cr5):02 */
8458 /* Config. Reg. 6 (Reserved) (cr6):00 */
8459 /* Config. Reg. 7 (Reserved) (cr7):00 */
8460 /* ;xr Registers */
8461 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8462
8463 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8464 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8465
8466 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8467 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8468
8469 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8470 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8471 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8472 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8473 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8474 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8475 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8476 /* Ext. Reg. 6 (Power State) (xr6):00 */
8477 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8478 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8479 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8480 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8481 /* 12,33,5A,C3 ; 770 Hz */
8482 /* 13,3C,5B,32 ; 852 Hz */
8483 /* 1D,1B,5C,CC ; 941 Hz */
8484
8485 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8486 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8489 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8490 /* EC,1D,52,22 ; 1336 Hz */
8491 /* AA,AC,51,D2 ; 1477 Hz */
8492 /* 9B,3B,51,25 ; 1633 Hz */
8493 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8496 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8497 }
8498
8499
8500 static void DAA_Coeff_Australia(IXJ *j)
8501 {
8502 int i;
8503
8504 j->daa_country = DAA_AUSTRALIA;
8505 /*----------------------------------------------- */
8506 /* CAO */
8507 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8508 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8509 }
8510
8511 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8512 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8520 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8528 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8529 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8530 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8538 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8546 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8547 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8548 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8549 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8550 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8551 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8552 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8553 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8554 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8555 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8556 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8557 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8558 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8566 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8575 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8583 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8584 /* ; idle */
8585 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8586 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8594 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8602 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8603 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8604 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8605 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8606 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8607 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8608 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8609 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8617 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8625 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8626 /* ;CR Registers */
8627 /* Config. Reg. 0 (filters) (cr0):FF */
8628 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8629 /* Config. Reg. 1 (dialing) (cr1):05 */
8630 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8631 /* Config. Reg. 2 (caller ID) (cr2):04 */
8632 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8633 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8634 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8635 /* Config. Reg. 4 (analog gain) (cr4):02 */
8636 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8637 /* Config. Reg. 5 (Version) (cr5):02 */
8638 /* Config. Reg. 6 (Reserved) (cr6):00 */
8639 /* Config. Reg. 7 (Reserved) (cr7):00 */
8640 /* ;xr Registers */
8641 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8642
8643 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8644 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8645
8646 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8647 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8648
8649 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8650 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8651 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8652 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8653 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8654 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8655 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8656 /* Ext. Reg. 6 (Power State) (xr6):00 */
8657 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8658 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8659 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8660
8661 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8662 /* 12,33,5A,C3 ; 770 Hz */
8663 /* 13,3C,5B,32 ; 852 Hz */
8664 /* 1D,1B,5C,CC ; 941 Hz */
8665 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8666 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8668 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8669
8670 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8671 /* EC,1D,52,22 ; 1336 Hz */
8672 /* AA,AC,51,D2 ; 1477 Hz */
8673 /* 9B,3B,51,25 ; 1633 Hz */
8674 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8675 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8677 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8678 }
8679
8680 static void DAA_Coeff_Japan(IXJ *j)
8681 {
8682 int i;
8683
8684 j->daa_country = DAA_JAPAN;
8685 /*----------------------------------------------- */
8686 /* CAO */
8687 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8688 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8689 }
8690
8691 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8692 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8700 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8708 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8709 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8710 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8718 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8726 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8727 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8728 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8729 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8730 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8731 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8732 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8733 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8734 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8735 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8736 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8737 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8738 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8746 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8755 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8763 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8764 /* ; idle */
8765 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8766 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8774 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8782 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8783 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8784 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8785 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8786 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8787 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8788 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8789 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8797 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8805 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8806 /* ;CR Registers */
8807 /* Config. Reg. 0 (filters) (cr0):FF */
8808 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8809 /* Config. Reg. 1 (dialing) (cr1):05 */
8810 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8811 /* Config. Reg. 2 (caller ID) (cr2):04 */
8812 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8813 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8814 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8815 /* Config. Reg. 4 (analog gain) (cr4):02 */
8816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8817 /* Config. Reg. 5 (Version) (cr5):02 */
8818 /* Config. Reg. 6 (Reserved) (cr6):00 */
8819 /* Config. Reg. 7 (Reserved) (cr7):00 */
8820 /* ;xr Registers */
8821 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8822
8823 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8824 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8825
8826 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8827 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8828
8829 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8830 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8831 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8832 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8833 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8834 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8835 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8836 /* Ext. Reg. 6 (Power State) (xr6):00 */
8837 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8838 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8839 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8840 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8841 /* 12,33,5A,C3 ; 770 Hz */
8842 /* 13,3C,5B,32 ; 852 Hz */
8843 /* 1D,1B,5C,CC ; 941 Hz */
8844
8845 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8846 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8849 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8850 /* EC,1D,52,22 ; 1336 Hz */
8851 /* AA,AC,51,D2 ; 1477 Hz */
8852 /* 9B,3B,51,25 ; 1633 Hz */
8853 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8856 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8857 }
8858
8859 static s16 tone_table[][19] =
8860 {
8861 { /* f20_50[] 11 */
8862 32538, /* A1 = 1.985962 */
8863 -32325, /* A2 = -0.986511 */
8864 -343, /* B2 = -0.010493 */
8865 0, /* B1 = 0 */
8866 343, /* B0 = 0.010493 */
8867 32619, /* A1 = 1.990906 */
8868 -32520, /* A2 = -0.992462 */
8869 19179, /* B2 = 0.585327 */
8870 -19178, /* B1 = -1.170593 */
8871 19179, /* B0 = 0.585327 */
8872 32723, /* A1 = 1.997314 */
8873 -32686, /* A2 = -0.997528 */
8874 9973, /* B2 = 0.304352 */
8875 -9955, /* B1 = -0.607605 */
8876 9973, /* B0 = 0.304352 */
8877 7, /* Internal filter scaling */
8878 159, /* Minimum in-band energy threshold */
8879 21, /* 21/32 in-band to broad-band ratio */
8880 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8881 },
8882 { /* f133_200[] 12 */
8883 32072, /* A1 = 1.95752 */
8884 -31896, /* A2 = -0.973419 */
8885 -435, /* B2 = -0.013294 */
8886 0, /* B1 = 0 */
8887 435, /* B0 = 0.013294 */
8888 32188, /* A1 = 1.9646 */
8889 -32400, /* A2 = -0.98877 */
8890 15139, /* B2 = 0.462036 */
8891 -14882, /* B1 = -0.908356 */
8892 15139, /* B0 = 0.462036 */
8893 32473, /* A1 = 1.981995 */
8894 -32524, /* A2 = -0.992584 */
8895 23200, /* B2 = 0.708008 */
8896 -23113, /* B1 = -1.410706 */
8897 23200, /* B0 = 0.708008 */
8898 7, /* Internal filter scaling */
8899 159, /* Minimum in-band energy threshold */
8900 21, /* 21/32 in-band to broad-band ratio */
8901 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8902 },
8903 { /* f300 13 */
8904 31769, /* A1 = -1.939026 */
8905 -32584, /* A2 = 0.994385 */
8906 -475, /* B2 = -0.014522 */
8907 0, /* B1 = 0.000000 */
8908 475, /* B0 = 0.014522 */
8909 31789, /* A1 = -1.940247 */
8910 -32679, /* A2 = 0.997284 */
8911 17280, /* B2 = 0.527344 */
8912 -16865, /* B1 = -1.029358 */
8913 17280, /* B0 = 0.527344 */
8914 31841, /* A1 = -1.943481 */
8915 -32681, /* A2 = 0.997345 */
8916 543, /* B2 = 0.016579 */
8917 -525, /* B1 = -0.032097 */
8918 543, /* B0 = 0.016579 */
8919 5, /* Internal filter scaling */
8920 159, /* Minimum in-band energy threshold */
8921 21, /* 21/32 in-band to broad-band ratio */
8922 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8923 },
8924 { /* f300_420[] 14 */
8925 30750, /* A1 = 1.876892 */
8926 -31212, /* A2 = -0.952515 */
8927 -804, /* B2 = -0.024541 */
8928 0, /* B1 = 0 */
8929 804, /* B0 = 0.024541 */
8930 30686, /* A1 = 1.872925 */
8931 -32145, /* A2 = -0.980988 */
8932 14747, /* B2 = 0.450043 */
8933 -13703, /* B1 = -0.836395 */
8934 14747, /* B0 = 0.450043 */
8935 31651, /* A1 = 1.931824 */
8936 -32321, /* A2 = -0.986389 */
8937 24425, /* B2 = 0.745422 */
8938 -23914, /* B1 = -1.459595 */
8939 24427, /* B0 = 0.745483 */
8940 7, /* Internal filter scaling */
8941 159, /* Minimum in-band energy threshold */
8942 21, /* 21/32 in-band to broad-band ratio */
8943 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8944 },
8945 { /* f330 15 */
8946 31613, /* A1 = -1.929565 */
8947 -32646, /* A2 = 0.996277 */
8948 -185, /* B2 = -0.005657 */
8949 0, /* B1 = 0.000000 */
8950 185, /* B0 = 0.005657 */
8951 31620, /* A1 = -1.929932 */
8952 -32713, /* A2 = 0.998352 */
8953 19253, /* B2 = 0.587585 */
8954 -18566, /* B1 = -1.133179 */
8955 19253, /* B0 = 0.587585 */
8956 31674, /* A1 = -1.933228 */
8957 -32715, /* A2 = 0.998413 */
8958 2575, /* B2 = 0.078590 */
8959 -2495, /* B1 = -0.152283 */
8960 2575, /* B0 = 0.078590 */
8961 5, /* Internal filter scaling */
8962 159, /* Minimum in-band energy threshold */
8963 21, /* 21/32 in-band to broad-band ratio */
8964 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8965 },
8966 { /* f300_425[] 16 */
8967 30741, /* A1 = 1.876282 */
8968 -31475, /* A2 = -0.960541 */
8969 -703, /* B2 = -0.021484 */
8970 0, /* B1 = 0 */
8971 703, /* B0 = 0.021484 */
8972 30688, /* A1 = 1.873047 */
8973 -32248, /* A2 = -0.984161 */
8974 14542, /* B2 = 0.443787 */
8975 -13523, /* B1 = -0.825439 */
8976 14542, /* B0 = 0.443817 */
8977 31494, /* A1 = 1.922302 */
8978 -32366, /* A2 = -0.987762 */
8979 21577, /* B2 = 0.658508 */
8980 -21013, /* B1 = -1.282532 */
8981 21577, /* B0 = 0.658508 */
8982 7, /* Internal filter scaling */
8983 159, /* Minimum in-band energy threshold */
8984 21, /* 21/32 in-band to broad-band ratio */
8985 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8986 },
8987 { /* f330_440[] 17 */
8988 30627, /* A1 = 1.869324 */
8989 -31338, /* A2 = -0.95636 */
8990 -843, /* B2 = -0.025749 */
8991 0, /* B1 = 0 */
8992 843, /* B0 = 0.025749 */
8993 30550, /* A1 = 1.864685 */
8994 -32221, /* A2 = -0.983337 */
8995 13594, /* B2 = 0.414886 */
8996 -12589, /* B1 = -0.768402 */
8997 13594, /* B0 = 0.414886 */
8998 31488, /* A1 = 1.921936 */
8999 -32358, /* A2 = -0.987518 */
9000 24684, /* B2 = 0.753296 */
9001 -24029, /* B1 = -1.466614 */
9002 24684, /* B0 = 0.753296 */
9003 7, /* Internal filter scaling */
9004 159, /* Minimum in-band energy threshold */
9005 21, /* 21/32 in-band to broad-band ratio */
9006 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9007 },
9008 { /* f340 18 */
9009 31546, /* A1 = -1.925476 */
9010 -32646, /* A2 = 0.996277 */
9011 -445, /* B2 = -0.013588 */
9012 0, /* B1 = 0.000000 */
9013 445, /* B0 = 0.013588 */
9014 31551, /* A1 = -1.925781 */
9015 -32713, /* A2 = 0.998352 */
9016 23884, /* B2 = 0.728882 */
9017 -22979, /* B1 = -1.402527 */
9018 23884, /* B0 = 0.728882 */
9019 31606, /* A1 = -1.929138 */
9020 -32715, /* A2 = 0.998413 */
9021 863, /* B2 = 0.026367 */
9022 -835, /* B1 = -0.050985 */
9023 863, /* B0 = 0.026367 */
9024 5, /* Internal filter scaling */
9025 159, /* Minimum in-band energy threshold */
9026 21, /* 21/32 in-band to broad-band ratio */
9027 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9028 },
9029 { /* f350_400[] 19 */
9030 31006, /* A1 = 1.892517 */
9031 -32029, /* A2 = -0.977448 */
9032 -461, /* B2 = -0.014096 */
9033 0, /* B1 = 0 */
9034 461, /* B0 = 0.014096 */
9035 30999, /* A1 = 1.892029 */
9036 -32487, /* A2 = -0.991455 */
9037 11325, /* B2 = 0.345612 */
9038 -10682, /* B1 = -0.651978 */
9039 11325, /* B0 = 0.345612 */
9040 31441, /* A1 = 1.919067 */
9041 -32526, /* A2 = -0.992615 */
9042 24324, /* B2 = 0.74231 */
9043 -23535, /* B1 = -1.436523 */
9044 24324, /* B0 = 0.74231 */
9045 7, /* Internal filter scaling */
9046 159, /* Minimum in-band energy threshold */
9047 21, /* 21/32 in-band to broad-band ratio */
9048 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9049 },
9050 { /* f350_440[] */
9051 30634, /* A1 = 1.869751 */
9052 -31533, /* A2 = -0.962341 */
9053 -680, /* B2 = -0.020782 */
9054 0, /* B1 = 0 */
9055 680, /* B0 = 0.020782 */
9056 30571, /* A1 = 1.865906 */
9057 -32277, /* A2 = -0.985016 */
9058 12894, /* B2 = 0.393524 */
9059 -11945, /* B1 = -0.729065 */
9060 12894, /* B0 = 0.393524 */
9061 31367, /* A1 = 1.91449 */
9062 -32379, /* A2 = -0.988129 */
9063 23820, /* B2 = 0.726929 */
9064 -23104, /* B1 = -1.410217 */
9065 23820, /* B0 = 0.726929 */
9066 7, /* Internal filter scaling */
9067 159, /* Minimum in-band energy threshold */
9068 21, /* 21/32 in-band to broad-band ratio */
9069 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9070 },
9071 { /* f350_450[] */
9072 30552, /* A1 = 1.864807 */
9073 -31434, /* A2 = -0.95929 */
9074 -690, /* B2 = -0.021066 */
9075 0, /* B1 = 0 */
9076 690, /* B0 = 0.021066 */
9077 30472, /* A1 = 1.859924 */
9078 -32248, /* A2 = -0.984161 */
9079 13385, /* B2 = 0.408478 */
9080 -12357, /* B1 = -0.754242 */
9081 13385, /* B0 = 0.408478 */
9082 31358, /* A1 = 1.914001 */
9083 -32366, /* A2 = -0.987732 */
9084 26488, /* B2 = 0.80835 */
9085 -25692, /* B1 = -1.568176 */
9086 26490, /* B0 = 0.808411 */
9087 7, /* Internal filter scaling */
9088 159, /* Minimum in-band energy threshold */
9089 21, /* 21/32 in-band to broad-band ratio */
9090 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9091 },
9092 { /* f360 */
9093 31397, /* A1 = -1.916321 */
9094 -32623, /* A2 = 0.995605 */
9095 -117, /* B2 = -0.003598 */
9096 0, /* B1 = 0.000000 */
9097 117, /* B0 = 0.003598 */
9098 31403, /* A1 = -1.916687 */
9099 -32700, /* A2 = 0.997925 */
9100 3388, /* B2 = 0.103401 */
9101 -3240, /* B1 = -0.197784 */
9102 3388, /* B0 = 0.103401 */
9103 31463, /* A1 = -1.920410 */
9104 -32702, /* A2 = 0.997986 */
9105 13346, /* B2 = 0.407288 */
9106 -12863, /* B1 = -0.785126 */
9107 13346, /* B0 = 0.407288 */
9108 5, /* Internal filter scaling */
9109 159, /* Minimum in-band energy threshold */
9110 21, /* 21/32 in-band to broad-band ratio */
9111 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9112 },
9113 { /* f380_420[] */
9114 30831, /* A1 = 1.881775 */
9115 -32064, /* A2 = -0.978546 */
9116 -367, /* B2 = -0.01122 */
9117 0, /* B1 = 0 */
9118 367, /* B0 = 0.01122 */
9119 30813, /* A1 = 1.880737 */
9120 -32456, /* A2 = -0.990509 */
9121 11068, /* B2 = 0.337769 */
9122 -10338, /* B1 = -0.631042 */
9123 11068, /* B0 = 0.337769 */
9124 31214, /* A1 = 1.905212 */
9125 -32491, /* A2 = -0.991577 */
9126 16374, /* B2 = 0.499695 */
9127 -15781, /* B1 = -0.963196 */
9128 16374, /* B0 = 0.499695 */
9129 7, /* Internal filter scaling */
9130 159, /* Minimum in-band energy threshold */
9131 21, /* 21/32 in-band to broad-band ratio */
9132 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9133 },
9134 { /* f392 */
9135 31152, /* A1 = -1.901428 */
9136 -32613, /* A2 = 0.995300 */
9137 -314, /* B2 = -0.009605 */
9138 0, /* B1 = 0.000000 */
9139 314, /* B0 = 0.009605 */
9140 31156, /* A1 = -1.901672 */
9141 -32694, /* A2 = 0.997742 */
9142 28847, /* B2 = 0.880371 */
9143 -2734, /* B1 = -0.166901 */
9144 28847, /* B0 = 0.880371 */
9145 31225, /* A1 = -1.905823 */
9146 -32696, /* A2 = 0.997803 */
9147 462, /* B2 = 0.014108 */
9148 -442, /* B1 = -0.027019 */
9149 462, /* B0 = 0.014108 */
9150 5, /* Internal filter scaling */
9151 159, /* Minimum in-band energy threshold */
9152 21, /* 21/32 in-band to broad-band ratio */
9153 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9154 },
9155 { /* f400_425[] */
9156 30836, /* A1 = 1.882141 */
9157 -32296, /* A2 = -0.985596 */
9158 -324, /* B2 = -0.009903 */
9159 0, /* B1 = 0 */
9160 324, /* B0 = 0.009903 */
9161 30825, /* A1 = 1.881409 */
9162 -32570, /* A2 = -0.993958 */
9163 16847, /* B2 = 0.51416 */
9164 -15792, /* B1 = -0.963898 */
9165 16847, /* B0 = 0.51416 */
9166 31106, /* A1 = 1.89856 */
9167 -32584, /* A2 = -0.994415 */
9168 9579, /* B2 = 0.292328 */
9169 -9164, /* B1 = -0.559357 */
9170 9579, /* B0 = 0.292328 */
9171 7, /* Internal filter scaling */
9172 159, /* Minimum in-band energy threshold */
9173 21, /* 21/32 in-band to broad-band ratio */
9174 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9175 },
9176 { /* f400_440[] */
9177 30702, /* A1 = 1.873962 */
9178 -32134, /* A2 = -0.980682 */
9179 -517, /* B2 = -0.015793 */
9180 0, /* B1 = 0 */
9181 517, /* B0 = 0.015793 */
9182 30676, /* A1 = 1.872375 */
9183 -32520, /* A2 = -0.992462 */
9184 8144, /* B2 = 0.24855 */
9185 -7596, /* B1 = -0.463684 */
9186 8144, /* B0 = 0.24855 */
9187 31084, /* A1 = 1.897217 */
9188 -32547, /* A2 = -0.993256 */
9189 22713, /* B2 = 0.693176 */
9190 -21734, /* B1 = -1.326599 */
9191 22713, /* B0 = 0.693176 */
9192 7, /* Internal filter scaling */
9193 159, /* Minimum in-band energy threshold */
9194 21, /* 21/32 in-band to broad-band ratio */
9195 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9196 },
9197 { /* f400_450[] */
9198 30613, /* A1 = 1.86853 */
9199 -32031, /* A2 = -0.977509 */
9200 -618, /* B2 = -0.018866 */
9201 0, /* B1 = 0 */
9202 618, /* B0 = 0.018866 */
9203 30577, /* A1 = 1.866272 */
9204 -32491, /* A2 = -0.991577 */
9205 9612, /* B2 = 0.293335 */
9206 -8935, /* B1 = -0.54541 */
9207 9612, /* B0 = 0.293335 */
9208 31071, /* A1 = 1.896484 */
9209 -32524, /* A2 = -0.992584 */
9210 21596, /* B2 = 0.659058 */
9211 -20667, /* B1 = -1.261414 */
9212 21596, /* B0 = 0.659058 */
9213 7, /* Internal filter scaling */
9214 159, /* Minimum in-band energy threshold */
9215 21, /* 21/32 in-band to broad-band ratio */
9216 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9217 },
9218 { /* f420 */
9219 30914, /* A1 = -1.886841 */
9220 -32584, /* A2 = 0.994385 */
9221 -426, /* B2 = -0.013020 */
9222 0, /* B1 = 0.000000 */
9223 426, /* B0 = 0.013020 */
9224 30914, /* A1 = -1.886841 */
9225 -32679, /* A2 = 0.997314 */
9226 17520, /* B2 = 0.534668 */
9227 -16471, /* B1 = -1.005310 */
9228 17520, /* B0 = 0.534668 */
9229 31004, /* A1 = -1.892334 */
9230 -32683, /* A2 = 0.997406 */
9231 819, /* B2 = 0.025023 */
9232 -780, /* B1 = -0.047619 */
9233 819, /* B0 = 0.025023 */
9234 5, /* Internal filter scaling */
9235 159, /* Minimum in-band energy threshold */
9236 21, /* 21/32 in-band to broad-band ratio */
9237 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9238 },
9239 #if 0
9240 { /* f425 */
9241 30881, /* A1 = -1.884827 */
9242 -32603, /* A2 = 0.994965 */
9243 -496, /* B2 = -0.015144 */
9244 0, /* B1 = 0.000000 */
9245 496, /* B0 = 0.015144 */
9246 30880, /* A1 = -1.884766 */
9247 -32692, /* A2 = 0.997711 */
9248 24767, /* B2 = 0.755859 */
9249 -23290, /* B1 = -1.421509 */
9250 24767, /* B0 = 0.755859 */
9251 30967, /* A1 = -1.890076 */
9252 -32694, /* A2 = 0.997772 */
9253 728, /* B2 = 0.022232 */
9254 -691, /* B1 = -0.042194 */
9255 728, /* B0 = 0.022232 */
9256 5, /* Internal filter scaling */
9257 159, /* Minimum in-band energy threshold */
9258 21, /* 21/32 in-band to broad-band ratio */
9259 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9260 },
9261 #else
9262 {
9263 30850,
9264 -32534,
9265 -504,
9266 0,
9267 504,
9268 30831,
9269 -32669,
9270 24303,
9271 -22080,
9272 24303,
9273 30994,
9274 -32673,
9275 1905,
9276 -1811,
9277 1905,
9278 5,
9279 129,
9280 17,
9281 0xff5
9282 },
9283 #endif
9284 { /* f425_450[] */
9285 30646, /* A1 = 1.870544 */
9286 -32327, /* A2 = -0.986572 */
9287 -287, /* B2 = -0.008769 */
9288 0, /* B1 = 0 */
9289 287, /* B0 = 0.008769 */
9290 30627, /* A1 = 1.869324 */
9291 -32607, /* A2 = -0.995087 */
9292 13269, /* B2 = 0.404968 */
9293 -12376, /* B1 = -0.755432 */
9294 13269, /* B0 = 0.404968 */
9295 30924, /* A1 = 1.887512 */
9296 -32619, /* A2 = -0.995453 */
9297 19950, /* B2 = 0.608826 */
9298 -18940, /* B1 = -1.156006 */
9299 19950, /* B0 = 0.608826 */
9300 7, /* Internal filter scaling */
9301 159, /* Minimum in-band energy threshold */
9302 21, /* 21/32 in-band to broad-band ratio */
9303 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9304 },
9305 { /* f425_475[] */
9306 30396, /* A1 = 1.855225 */
9307 -32014, /* A2 = -0.97699 */
9308 -395, /* B2 = -0.012055 */
9309 0, /* B1 = 0 */
9310 395, /* B0 = 0.012055 */
9311 30343, /* A1 = 1.85199 */
9312 -32482, /* A2 = -0.991302 */
9313 17823, /* B2 = 0.543945 */
9314 -16431, /* B1 = -1.002869 */
9315 17823, /* B0 = 0.543945 */
9316 30872, /* A1 = 1.884338 */
9317 -32516, /* A2 = -0.99231 */
9318 18124, /* B2 = 0.553101 */
9319 -17246, /* B1 = -1.052673 */
9320 18124, /* B0 = 0.553101 */
9321 7, /* Internal filter scaling */
9322 159, /* Minimum in-band energy threshold */
9323 21, /* 21/32 in-band to broad-band ratio */
9324 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9325 },
9326 { /* f435 */
9327 30796, /* A1 = -1.879639 */
9328 -32603, /* A2 = 0.994965 */
9329 -254, /* B2 = -0.007762 */
9330 0, /* B1 = 0.000000 */
9331 254, /* B0 = 0.007762 */
9332 30793, /* A1 = -1.879456 */
9333 -32692, /* A2 = 0.997711 */
9334 18934, /* B2 = 0.577820 */
9335 -17751, /* B1 = -1.083496 */
9336 18934, /* B0 = 0.577820 */
9337 30882, /* A1 = -1.884888 */
9338 -32694, /* A2 = 0.997772 */
9339 1858, /* B2 = 0.056713 */
9340 -1758, /* B1 = -0.107357 */
9341 1858, /* B0 = 0.056713 */
9342 5, /* Internal filter scaling */
9343 159, /* Minimum in-band energy threshold */
9344 21, /* 21/32 in-band to broad-band ratio */
9345 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9346 },
9347 { /* f440_450[] */
9348 30641, /* A1 = 1.870239 */
9349 -32458, /* A2 = -0.99057 */
9350 -155, /* B2 = -0.004735 */
9351 0, /* B1 = 0 */
9352 155, /* B0 = 0.004735 */
9353 30631, /* A1 = 1.869568 */
9354 -32630, /* A2 = -0.995789 */
9355 11453, /* B2 = 0.349548 */
9356 -10666, /* B1 = -0.651001 */
9357 11453, /* B0 = 0.349548 */
9358 30810, /* A1 = 1.880554 */
9359 -32634, /* A2 = -0.995941 */
9360 12237, /* B2 = 0.373474 */
9361 -11588, /* B1 = -0.707336 */
9362 12237, /* B0 = 0.373474 */
9363 7, /* Internal filter scaling */
9364 159, /* Minimum in-band energy threshold */
9365 21, /* 21/32 in-band to broad-band ratio */
9366 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9367 },
9368 { /* f440_480[] */
9369 30367, /* A1 = 1.853455 */
9370 -32147, /* A2 = -0.981079 */
9371 -495, /* B2 = -0.015113 */
9372 0, /* B1 = 0 */
9373 495, /* B0 = 0.015113 */
9374 30322, /* A1 = 1.850769 */
9375 -32543, /* A2 = -0.993134 */
9376 10031, /* B2 = 0.306152 */
9377 -9252, /* B1 = -0.564728 */
9378 10031, /* B0 = 0.306152 */
9379 30770, /* A1 = 1.878052 */
9380 -32563, /* A2 = -0.993774 */
9381 22674, /* B2 = 0.691956 */
9382 -21465, /* B1 = -1.31012 */
9383 22674, /* B0 = 0.691956 */
9384 7, /* Internal filter scaling */
9385 159, /* Minimum in-band energy threshold */
9386 21, /* 21/32 in-band to broad-band ratio */
9387 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9388 },
9389 { /* f445 */
9390 30709, /* A1 = -1.874329 */
9391 -32603, /* A2 = 0.994965 */
9392 -83, /* B2 = -0.002545 */
9393 0, /* B1 = 0.000000 */
9394 83, /* B0 = 0.002545 */
9395 30704, /* A1 = -1.874084 */
9396 -32692, /* A2 = 0.997711 */
9397 10641, /* B2 = 0.324738 */
9398 -9947, /* B1 = -0.607147 */
9399 10641, /* B0 = 0.324738 */
9400 30796, /* A1 = -1.879639 */
9401 -32694, /* A2 = 0.997772 */
9402 10079, /* B2 = 0.307587 */
9403 9513, /* B1 = 0.580688 */
9404 10079, /* B0 = 0.307587 */
9405 5, /* Internal filter scaling */
9406 159, /* Minimum in-band energy threshold */
9407 21, /* 21/32 in-band to broad-band ratio */
9408 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9409 },
9410 { /* f450 */
9411 30664, /* A1 = -1.871643 */
9412 -32603, /* A2 = 0.994965 */
9413 -164, /* B2 = -0.005029 */
9414 0, /* B1 = 0.000000 */
9415 164, /* B0 = 0.005029 */
9416 30661, /* A1 = -1.871399 */
9417 -32692, /* A2 = 0.997711 */
9418 15294, /* B2 = 0.466736 */
9419 -14275, /* B1 = -0.871307 */
9420 15294, /* B0 = 0.466736 */
9421 30751, /* A1 = -1.876953 */
9422 -32694, /* A2 = 0.997772 */
9423 3548, /* B2 = 0.108284 */
9424 -3344, /* B1 = -0.204155 */
9425 3548, /* B0 = 0.108284 */
9426 5, /* Internal filter scaling */
9427 159, /* Minimum in-band energy threshold */
9428 21, /* 21/32 in-band to broad-band ratio */
9429 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9430 },
9431 { /* f452 */
9432 30653, /* A1 = -1.870911 */
9433 -32615, /* A2 = 0.995361 */
9434 -209, /* B2 = -0.006382 */
9435 0, /* B1 = 0.000000 */
9436 209, /* B0 = 0.006382 */
9437 30647, /* A1 = -1.870605 */
9438 -32702, /* A2 = 0.997986 */
9439 18971, /* B2 = 0.578979 */
9440 -17716, /* B1 = -1.081299 */
9441 18971, /* B0 = 0.578979 */
9442 30738, /* A1 = -1.876099 */
9443 -32702, /* A2 = 0.998016 */
9444 2967, /* B2 = 0.090561 */
9445 -2793, /* B1 = -0.170502 */
9446 2967, /* B0 = 0.090561 */
9447 5, /* Internal filter scaling */
9448 159, /* Minimum in-band energy threshold */
9449 21, /* 21/32 in-band to broad-band ratio */
9450 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9451 },
9452 { /* f475 */
9453 30437, /* A1 = -1.857727 */
9454 -32603, /* A2 = 0.994965 */
9455 -264, /* B2 = -0.008062 */
9456 0, /* B1 = 0.000000 */
9457 264, /* B0 = 0.008062 */
9458 30430, /* A1 = -1.857300 */
9459 -32692, /* A2 = 0.997711 */
9460 21681, /* B2 = 0.661682 */
9461 -20082, /* B1 = -1.225708 */
9462 21681, /* B0 = 0.661682 */
9463 30526, /* A1 = -1.863220 */
9464 -32694, /* A2 = 0.997742 */
9465 1559, /* B2 = 0.047600 */
9466 -1459, /* B1 = -0.089096 */
9467 1559, /* B0 = 0.047600 */
9468 5, /* Internal filter scaling */
9469 159, /* Minimum in-band energy threshold */
9470 21, /* 21/32 in-band to broad-band ratio */
9471 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9472 },
9473 { /* f480_620[] */
9474 28975, /* A1 = 1.768494 */
9475 -30955, /* A2 = -0.944672 */
9476 -1026, /* B2 = -0.03133 */
9477 0, /* B1 = 0 */
9478 1026, /* B0 = 0.03133 */
9479 28613, /* A1 = 1.746399 */
9480 -32089, /* A2 = -0.979309 */
9481 14214, /* B2 = 0.433807 */
9482 -12202, /* B1 = -0.744812 */
9483 14214, /* B0 = 0.433807 */
9484 30243, /* A1 = 1.845947 */
9485 -32238, /* A2 = -0.983856 */
9486 24825, /* B2 = 0.757629 */
9487 -23402, /* B1 = -1.428345 */
9488 24825, /* B0 = 0.757629 */
9489 7, /* Internal filter scaling */
9490 159, /* Minimum in-band energy threshold */
9491 21, /* 21/32 in-band to broad-band ratio */
9492 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9493 },
9494 { /* f494 */
9495 30257, /* A1 = -1.846741 */
9496 -32605, /* A2 = 0.995056 */
9497 -249, /* B2 = -0.007625 */
9498 0, /* B1 = 0.000000 */
9499 249, /* B0 = 0.007625 */
9500 30247, /* A1 = -1.846191 */
9501 -32694, /* A2 = 0.997772 */
9502 18088, /* B2 = 0.552002 */
9503 -16652, /* B1 = -1.016418 */
9504 18088, /* B0 = 0.552002 */
9505 30348, /* A1 = -1.852295 */
9506 -32696, /* A2 = 0.997803 */
9507 2099, /* B2 = 0.064064 */
9508 -1953, /* B1 = -0.119202 */
9509 2099, /* B0 = 0.064064 */
9510 5, /* Internal filter scaling */
9511 159, /* Minimum in-band energy threshold */
9512 21, /* 21/32 in-band to broad-band ratio */
9513 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9514 },
9515 { /* f500 */
9516 30202, /* A1 = -1.843431 */
9517 -32624, /* A2 = 0.995622 */
9518 -413, /* B2 = -0.012622 */
9519 0, /* B1 = 0.000000 */
9520 413, /* B0 = 0.012622 */
9521 30191, /* A1 = -1.842721 */
9522 -32714, /* A2 = 0.998364 */
9523 25954, /* B2 = 0.792057 */
9524 -23890, /* B1 = -1.458131 */
9525 25954, /* B0 = 0.792057 */
9526 30296, /* A1 = -1.849172 */
9527 -32715, /* A2 = 0.998397 */
9528 2007, /* B2 = 0.061264 */
9529 -1860, /* B1 = -0.113568 */
9530 2007, /* B0 = 0.061264 */
9531 5, /* Internal filter scaling */
9532 159, /* Minimum in-band energy threshold */
9533 21, /* 21/32 in-band to broad-band ratio */
9534 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9535 },
9536 { /* f520 */
9537 30001, /* A1 = -1.831116 */
9538 -32613, /* A2 = 0.995270 */
9539 -155, /* B2 = -0.004750 */
9540 0, /* B1 = 0.000000 */
9541 155, /* B0 = 0.004750 */
9542 29985, /* A1 = -1.830200 */
9543 -32710, /* A2 = 0.998260 */
9544 6584, /* B2 = 0.200928 */
9545 -6018, /* B1 = -0.367355 */
9546 6584, /* B0 = 0.200928 */
9547 30105, /* A1 = -1.837524 */
9548 -32712, /* A2 = 0.998291 */
9549 23812, /* B2 = 0.726685 */
9550 -21936, /* B1 = -1.338928 */
9551 23812, /* B0 = 0.726685 */
9552 5, /* Internal filter scaling */
9553 159, /* Minimum in-band energy threshold */
9554 21, /* 21/32 in-band to broad-band ratio */
9555 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9556 },
9557 { /* f523 */
9558 29964, /* A1 = -1.828918 */
9559 -32601, /* A2 = 0.994904 */
9560 -101, /* B2 = -0.003110 */
9561 0, /* B1 = 0.000000 */
9562 101, /* B0 = 0.003110 */
9563 29949, /* A1 = -1.827942 */
9564 -32700, /* A2 = 0.997925 */
9565 11041, /* B2 = 0.336975 */
9566 -10075, /* B1 = -0.614960 */
9567 11041, /* B0 = 0.336975 */
9568 30070, /* A1 = -1.835388 */
9569 -32702, /* A2 = 0.997986 */
9570 16762, /* B2 = 0.511536 */
9571 -15437, /* B1 = -0.942230 */
9572 16762, /* B0 = 0.511536 */
9573 5, /* Internal filter scaling */
9574 159, /* Minimum in-band energy threshold */
9575 21, /* 21/32 in-band to broad-band ratio */
9576 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9577 },
9578 { /* f525 */
9579 29936, /* A1 = -1.827209 */
9580 -32584, /* A2 = 0.994415 */
9581 -91, /* B2 = -0.002806 */
9582 0, /* B1 = 0.000000 */
9583 91, /* B0 = 0.002806 */
9584 29921, /* A1 = -1.826233 */
9585 -32688, /* A2 = 0.997559 */
9586 11449, /* B2 = 0.349396 */
9587 -10426, /* B1 = -0.636383 */
9588 11449, /* B0 = 0.349396 */
9589 30045, /* A1 = -1.833862 */
9590 -32688, /* A2 = 0.997589 */
9591 13055, /* B2 = 0.398407 */
9592 -12028, /* B1 = -0.734161 */
9593 13055, /* B0 = 0.398407 */
9594 5, /* Internal filter scaling */
9595 159, /* Minimum in-band energy threshold */
9596 21, /* 21/32 in-band to broad-band ratio */
9597 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9598 },
9599 { /* f540_660[] */
9600 28499, /* A1 = 1.739441 */
9601 -31129, /* A2 = -0.949982 */
9602 -849, /* B2 = -0.025922 */
9603 0, /* B1 = 0 */
9604 849, /* B0 = 0.025922 */
9605 28128, /* A1 = 1.716797 */
9606 -32130, /* A2 = -0.98056 */
9607 14556, /* B2 = 0.444214 */
9608 -12251, /* B1 = -0.747772 */
9609 14556, /* B0 = 0.444244 */
9610 29667, /* A1 = 1.81073 */
9611 -32244, /* A2 = -0.984039 */
9612 23038, /* B2 = 0.703064 */
9613 -21358, /* B1 = -1.303589 */
9614 23040, /* B0 = 0.703125 */
9615 7, /* Internal filter scaling */
9616 159, /* Minimum in-band energy threshold */
9617 21, /* 21/32 in-band to broad-band ratio */
9618 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9619 },
9620 { /* f587 */
9621 29271, /* A1 = -1.786560 */
9622 -32599, /* A2 = 0.994873 */
9623 -490, /* B2 = -0.014957 */
9624 0, /* B1 = 0.000000 */
9625 490, /* B0 = 0.014957 */
9626 29246, /* A1 = -1.785095 */
9627 -32700, /* A2 = 0.997925 */
9628 28961, /* B2 = 0.883850 */
9629 -25796, /* B1 = -1.574463 */
9630 28961, /* B0 = 0.883850 */
9631 29383, /* A1 = -1.793396 */
9632 -32700, /* A2 = 0.997955 */
9633 1299, /* B2 = 0.039650 */
9634 -1169, /* B1 = -0.071396 */
9635 1299, /* B0 = 0.039650 */
9636 5, /* Internal filter scaling */
9637 159, /* Minimum in-band energy threshold */
9638 21, /* 21/32 in-band to broad-band ratio */
9639 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9640 },
9641 { /* f590 */
9642 29230, /* A1 = -1.784058 */
9643 -32584, /* A2 = 0.994415 */
9644 -418, /* B2 = -0.012757 */
9645 0, /* B1 = 0.000000 */
9646 418, /* B0 = 0.012757 */
9647 29206, /* A1 = -1.782593 */
9648 -32688, /* A2 = 0.997559 */
9649 36556, /* B2 = 1.115601 */
9650 -32478, /* B1 = -1.982300 */
9651 36556, /* B0 = 1.115601 */
9652 29345, /* A1 = -1.791077 */
9653 -32688, /* A2 = 0.997589 */
9654 897, /* B2 = 0.027397 */
9655 -808, /* B1 = -0.049334 */
9656 897, /* B0 = 0.027397 */
9657 5, /* Internal filter scaling */
9658 159, /* Minimum in-band energy threshold */
9659 21, /* 21/32 in-band to broad-band ratio */
9660 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9661 },
9662 { /* f600 */
9663 29116, /* A1 = -1.777100 */
9664 -32603, /* A2 = 0.994965 */
9665 -165, /* B2 = -0.005039 */
9666 0, /* B1 = 0.000000 */
9667 165, /* B0 = 0.005039 */
9668 29089, /* A1 = -1.775452 */
9669 -32708, /* A2 = 0.998199 */
9670 6963, /* B2 = 0.212494 */
9671 -6172, /* B1 = -0.376770 */
9672 6963, /* B0 = 0.212494 */
9673 29237, /* A1 = -1.784485 */
9674 -32710, /* A2 = 0.998230 */
9675 24197, /* B2 = 0.738464 */
9676 -21657, /* B1 = -1.321899 */
9677 24197, /* B0 = 0.738464 */
9678 5, /* Internal filter scaling */
9679 159, /* Minimum in-band energy threshold */
9680 21, /* 21/32 in-band to broad-band ratio */
9681 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9682 },
9683 { /* f660 */
9684 28376, /* A1 = -1.731934 */
9685 -32567, /* A2 = 0.993896 */
9686 -363, /* B2 = -0.011102 */
9687 0, /* B1 = 0.000000 */
9688 363, /* B0 = 0.011102 */
9689 28337, /* A1 = -1.729614 */
9690 -32683, /* A2 = 0.997434 */
9691 21766, /* B2 = 0.664246 */
9692 -18761, /* B1 = -1.145081 */
9693 21766, /* B0 = 0.664246 */
9694 28513, /* A1 = -1.740356 */
9695 -32686, /* A2 = 0.997498 */
9696 2509, /* B2 = 0.076584 */
9697 -2196, /* B1 = -0.134041 */
9698 2509, /* B0 = 0.076584 */
9699 5, /* Internal filter scaling */
9700 159, /* Minimum in-band energy threshold */
9701 21, /* 21/32 in-band to broad-band ratio */
9702 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9703 },
9704 { /* f700 */
9705 27844, /* A1 = -1.699463 */
9706 -32563, /* A2 = 0.993744 */
9707 -366, /* B2 = -0.011187 */
9708 0, /* B1 = 0.000000 */
9709 366, /* B0 = 0.011187 */
9710 27797, /* A1 = -1.696655 */
9711 -32686, /* A2 = 0.997498 */
9712 22748, /* B2 = 0.694214 */
9713 -19235, /* B1 = -1.174072 */
9714 22748, /* B0 = 0.694214 */
9715 27995, /* A1 = -1.708740 */
9716 -32688, /* A2 = 0.997559 */
9717 2964, /* B2 = 0.090477 */
9718 -2546, /* B1 = -0.155449 */
9719 2964, /* B0 = 0.090477 */
9720 5, /* Internal filter scaling */
9721 159, /* Minimum in-band energy threshold */
9722 21, /* 21/32 in-band to broad-band ratio */
9723 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9724 },
9725 { /* f740 */
9726 27297, /* A1 = -1.666077 */
9727 -32551, /* A2 = 0.993408 */
9728 -345, /* B2 = -0.010540 */
9729 0, /* B1 = 0.000000 */
9730 345, /* B0 = 0.010540 */
9731 27240, /* A1 = -1.662598 */
9732 -32683, /* A2 = 0.997406 */
9733 22560, /* B2 = 0.688477 */
9734 -18688, /* B1 = -1.140625 */
9735 22560, /* B0 = 0.688477 */
9736 27461, /* A1 = -1.676147 */
9737 -32684, /* A2 = 0.997467 */
9738 3541, /* B2 = 0.108086 */
9739 -2985, /* B1 = -0.182220 */
9740 3541, /* B0 = 0.108086 */
9741 5, /* Internal filter scaling */
9742 159, /* Minimum in-band energy threshold */
9743 21, /* 21/32 in-band to broad-band ratio */
9744 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9745 },
9746 { /* f750 */
9747 27155, /* A1 = -1.657410 */
9748 -32551, /* A2 = 0.993408 */
9749 -462, /* B2 = -0.014117 */
9750 0, /* B1 = 0.000000 */
9751 462, /* B0 = 0.014117 */
9752 27097, /* A1 = -1.653870 */
9753 -32683, /* A2 = 0.997406 */
9754 32495, /* B2 = 0.991699 */
9755 -26776, /* B1 = -1.634338 */
9756 32495, /* B0 = 0.991699 */
9757 27321, /* A1 = -1.667542 */
9758 -32684, /* A2 = 0.997467 */
9759 1835, /* B2 = 0.056007 */
9760 -1539, /* B1 = -0.093948 */
9761 1835, /* B0 = 0.056007 */
9762 5, /* Internal filter scaling */
9763 159, /* Minimum in-band energy threshold */
9764 21, /* 21/32 in-band to broad-band ratio */
9765 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9766 },
9767 { /* f750_1450[] */
9768 19298, /* A1 = 1.177917 */
9769 -24471, /* A2 = -0.746796 */
9770 -4152, /* B2 = -0.126709 */
9771 0, /* B1 = 0 */
9772 4152, /* B0 = 0.126709 */
9773 12902, /* A1 = 0.787476 */
9774 -29091, /* A2 = -0.887817 */
9775 12491, /* B2 = 0.38121 */
9776 -1794, /* B1 = -0.109528 */
9777 12494, /* B0 = 0.381317 */
9778 26291, /* A1 = 1.604736 */
9779 -30470, /* A2 = -0.929901 */
9780 28859, /* B2 = 0.880737 */
9781 -26084, /* B1 = -1.592102 */
9782 28861, /* B0 = 0.880798 */
9783 7, /* Internal filter scaling */
9784 159, /* Minimum in-band energy threshold */
9785 21, /* 21/32 in-band to broad-band ratio */
9786 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9787 },
9788 { /* f770 */
9789 26867, /* A1 = -1.639832 */
9790 -32551, /* A2 = 0.993408 */
9791 -123, /* B2 = -0.003755 */
9792 0, /* B1 = 0.000000 */
9793 123, /* B0 = 0.003755 */
9794 26805, /* A1 = -1.636108 */
9795 -32683, /* A2 = 0.997406 */
9796 17297, /* B2 = 0.527863 */
9797 -14096, /* B1 = -0.860382 */
9798 17297, /* B0 = 0.527863 */
9799 27034, /* A1 = -1.650085 */
9800 -32684, /* A2 = 0.997467 */
9801 12958, /* B2 = 0.395477 */
9802 -10756, /* B1 = -0.656525 */
9803 12958, /* B0 = 0.395477 */
9804 5, /* Internal filter scaling */
9805 159, /* Minimum in-band energy threshold */
9806 21, /* 21/32 in-band to broad-band ratio */
9807 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9808 },
9809 { /* f800 */
9810 26413, /* A1 = -1.612122 */
9811 -32547, /* A2 = 0.993286 */
9812 -223, /* B2 = -0.006825 */
9813 0, /* B1 = 0.000000 */
9814 223, /* B0 = 0.006825 */
9815 26342, /* A1 = -1.607849 */
9816 -32686, /* A2 = 0.997498 */
9817 6391, /* B2 = 0.195053 */
9818 -5120, /* B1 = -0.312531 */
9819 6391, /* B0 = 0.195053 */
9820 26593, /* A1 = -1.623108 */
9821 -32688, /* A2 = 0.997559 */
9822 23681, /* B2 = 0.722717 */
9823 -19328, /* B1 = -1.179688 */
9824 23681, /* B0 = 0.722717 */
9825 5, /* Internal filter scaling */
9826 159, /* Minimum in-band energy threshold */
9827 21, /* 21/32 in-band to broad-band ratio */
9828 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9829 },
9830 { /* f816 */
9831 26168, /* A1 = -1.597209 */
9832 -32528, /* A2 = 0.992706 */
9833 -235, /* B2 = -0.007182 */
9834 0, /* B1 = 0.000000 */
9835 235, /* B0 = 0.007182 */
9836 26092, /* A1 = -1.592590 */
9837 -32675, /* A2 = 0.997192 */
9838 20823, /* B2 = 0.635498 */
9839 -16510, /* B1 = -1.007751 */
9840 20823, /* B0 = 0.635498 */
9841 26363, /* A1 = -1.609070 */
9842 -32677, /* A2 = 0.997253 */
9843 6739, /* B2 = 0.205688 */
9844 -5459, /* B1 = -0.333206 */
9845 6739, /* B0 = 0.205688 */
9846 5, /* Internal filter scaling */
9847 159, /* Minimum in-band energy threshold */
9848 21, /* 21/32 in-band to broad-band ratio */
9849 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9850 },
9851 { /* f850 */
9852 25641, /* A1 = -1.565063 */
9853 -32536, /* A2 = 0.992950 */
9854 -121, /* B2 = -0.003707 */
9855 0, /* B1 = 0.000000 */
9856 121, /* B0 = 0.003707 */
9857 25560, /* A1 = -1.560059 */
9858 -32684, /* A2 = 0.997437 */
9859 18341, /* B2 = 0.559753 */
9860 -14252, /* B1 = -0.869904 */
9861 18341, /* B0 = 0.559753 */
9862 25837, /* A1 = -1.577026 */
9863 -32684, /* A2 = 0.997467 */
9864 16679, /* B2 = 0.509003 */
9865 -13232, /* B1 = -0.807648 */
9866 16679, /* B0 = 0.509003 */
9867 5, /* Internal filter scaling */
9868 159, /* Minimum in-band energy threshold */
9869 21, /* 21/32 in-band to broad-band ratio */
9870 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9871 },
9872 { /* f857_1645[] */
9873 16415, /* A1 = 1.001953 */
9874 -23669, /* A2 = -0.722321 */
9875 -4549, /* B2 = -0.138847 */
9876 0, /* B1 = 0 */
9877 4549, /* B0 = 0.138847 */
9878 8456, /* A1 = 0.516174 */
9879 -28996, /* A2 = -0.884918 */
9880 13753, /* B2 = 0.419724 */
9881 -12, /* B1 = -0.000763 */
9882 13757, /* B0 = 0.419846 */
9883 24632, /* A1 = 1.503418 */
9884 -30271, /* A2 = -0.923828 */
9885 29070, /* B2 = 0.887146 */
9886 -25265, /* B1 = -1.542114 */
9887 29073, /* B0 = 0.887268 */
9888 7, /* Internal filter scaling */
9889 159, /* Minimum in-band energy threshold */
9890 21, /* 21/32 in-band to broad-band ratio */
9891 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9892 },
9893 { /* f900 */
9894 24806, /* A1 = -1.514099 */
9895 -32501, /* A2 = 0.991852 */
9896 -326, /* B2 = -0.009969 */
9897 0, /* B1 = 0.000000 */
9898 326, /* B0 = 0.009969 */
9899 24709, /* A1 = -1.508118 */
9900 -32659, /* A2 = 0.996674 */
9901 20277, /* B2 = 0.618835 */
9902 -15182, /* B1 = -0.926636 */
9903 20277, /* B0 = 0.618835 */
9904 25022, /* A1 = -1.527222 */
9905 -32661, /* A2 = 0.996735 */
9906 4320, /* B2 = 0.131836 */
9907 -3331, /* B1 = -0.203339 */
9908 4320, /* B0 = 0.131836 */
9909 5, /* Internal filter scaling */
9910 159, /* Minimum in-band energy threshold */
9911 21, /* 21/32 in-band to broad-band ratio */
9912 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9913 },
9914 { /* f900_1300[] */
9915 19776, /* A1 = 1.207092 */
9916 -27437, /* A2 = -0.837341 */
9917 -2666, /* B2 = -0.081371 */
9918 0, /* B1 = 0 */
9919 2666, /* B0 = 0.081371 */
9920 16302, /* A1 = 0.995026 */
9921 -30354, /* A2 = -0.926361 */
9922 10389, /* B2 = 0.317062 */
9923 -3327, /* B1 = -0.203064 */
9924 10389, /* B0 = 0.317062 */
9925 24299, /* A1 = 1.483154 */
9926 -30930, /* A2 = -0.943909 */
9927 25016, /* B2 = 0.763428 */
9928 -21171, /* B1 = -1.292236 */
9929 25016, /* B0 = 0.763428 */
9930 7, /* Internal filter scaling */
9931 159, /* Minimum in-band energy threshold */
9932 21, /* 21/32 in-band to broad-band ratio */
9933 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9934 },
9935 { /* f935_1215[] */
9936 20554, /* A1 = 1.254517 */
9937 -28764, /* A2 = -0.877838 */
9938 -2048, /* B2 = -0.062515 */
9939 0, /* B1 = 0 */
9940 2048, /* B0 = 0.062515 */
9941 18209, /* A1 = 1.11145 */
9942 -30951, /* A2 = -0.94458 */
9943 9390, /* B2 = 0.286575 */
9944 -3955, /* B1 = -0.241455 */
9945 9390, /* B0 = 0.286575 */
9946 23902, /* A1 = 1.458923 */
9947 -31286, /* A2 = -0.954803 */
9948 23252, /* B2 = 0.709595 */
9949 -19132, /* B1 = -1.167725 */
9950 23252, /* B0 = 0.709595 */
9951 7, /* Internal filter scaling */
9952 159, /* Minimum in-band energy threshold */
9953 21, /* 21/32 in-band to broad-band ratio */
9954 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9955 },
9956 { /* f941_1477[] */
9957 17543, /* A1 = 1.07074 */
9958 -26220, /* A2 = -0.800201 */
9959 -3298, /* B2 = -0.100647 */
9960 0, /* B1 = 0 */
9961 3298, /* B0 = 0.100647 */
9962 12423, /* A1 = 0.75827 */
9963 -30036, /* A2 = -0.916626 */
9964 12651, /* B2 = 0.386078 */
9965 -2444, /* B1 = -0.14917 */
9966 12653, /* B0 = 0.386154 */
9967 23518, /* A1 = 1.435425 */
9968 -30745, /* A2 = -0.938293 */
9969 27282, /* B2 = 0.832581 */
9970 -22529, /* B1 = -1.375122 */
9971 27286, /* B0 = 0.832703 */
9972 7, /* Internal filter scaling */
9973 159, /* Minimum in-band energy threshold */
9974 21, /* 21/32 in-band to broad-band ratio */
9975 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9976 },
9977 { /* f942 */
9978 24104, /* A1 = -1.471252 */
9979 -32507, /* A2 = 0.992065 */
9980 -351, /* B2 = -0.010722 */
9981 0, /* B1 = 0.000000 */
9982 351, /* B0 = 0.010722 */
9983 23996, /* A1 = -1.464600 */
9984 -32671, /* A2 = 0.997040 */
9985 22848, /* B2 = 0.697266 */
9986 -16639, /* B1 = -1.015564 */
9987 22848, /* B0 = 0.697266 */
9988 24332, /* A1 = -1.485168 */
9989 -32673, /* A2 = 0.997101 */
9990 4906, /* B2 = 0.149727 */
9991 -3672, /* B1 = -0.224174 */
9992 4906, /* B0 = 0.149727 */
9993 5, /* Internal filter scaling */
9994 159, /* Minimum in-band energy threshold */
9995 21, /* 21/32 in-band to broad-band ratio */
9996 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9997 },
9998 { /* f950 */
9999 23967, /* A1 = -1.462830 */
10000 -32507, /* A2 = 0.992065 */
10001 -518, /* B2 = -0.015821 */
10002 0, /* B1 = 0.000000 */
10003 518, /* B0 = 0.015821 */
10004 23856, /* A1 = -1.456055 */
10005 -32671, /* A2 = 0.997040 */
10006 26287, /* B2 = 0.802246 */
10007 -19031, /* B1 = -1.161560 */
10008 26287, /* B0 = 0.802246 */
10009 24195, /* A1 = -1.476746 */
10010 -32673, /* A2 = 0.997101 */
10011 2890, /* B2 = 0.088196 */
10012 -2151, /* B1 = -0.131317 */
10013 2890, /* B0 = 0.088196 */
10014 5, /* Internal filter scaling */
10015 159, /* Minimum in-band energy threshold */
10016 21, /* 21/32 in-band to broad-band ratio */
10017 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10018 },
10019 { /* f950_1400[] */
10020 18294, /* A1 = 1.116638 */
10021 -26962, /* A2 = -0.822845 */
10022 -2914, /* B2 = -0.088936 */
10023 0, /* B1 = 0 */
10024 2914, /* B0 = 0.088936 */
10025 14119, /* A1 = 0.861786 */
10026 -30227, /* A2 = -0.922455 */
10027 11466, /* B2 = 0.349945 */
10028 -2833, /* B1 = -0.172943 */
10029 11466, /* B0 = 0.349945 */
10030 23431, /* A1 = 1.430115 */
10031 -30828, /* A2 = -0.940796 */
10032 25331, /* B2 = 0.773071 */
10033 -20911, /* B1 = -1.276367 */
10034 25331, /* B0 = 0.773071 */
10035 7, /* Internal filter scaling */
10036 159, /* Minimum in-band energy threshold */
10037 21, /* 21/32 in-band to broad-band ratio */
10038 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10039 },
10040 { /* f975 */
10041 23521, /* A1 = -1.435608 */
10042 -32489, /* A2 = 0.991516 */
10043 -193, /* B2 = -0.005915 */
10044 0, /* B1 = 0.000000 */
10045 193, /* B0 = 0.005915 */
10046 23404, /* A1 = -1.428467 */
10047 -32655, /* A2 = 0.996582 */
10048 17740, /* B2 = 0.541412 */
10049 -12567, /* B1 = -0.767029 */
10050 17740, /* B0 = 0.541412 */
10051 23753, /* A1 = -1.449829 */
10052 -32657, /* A2 = 0.996613 */
10053 9090, /* B2 = 0.277405 */
10054 -6662, /* B1 = -0.406647 */
10055 9090, /* B0 = 0.277405 */
10056 5, /* Internal filter scaling */
10057 159, /* Minimum in-band energy threshold */
10058 21, /* 21/32 in-band to broad-band ratio */
10059 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10060 },
10061 { /* f1000 */
10062 23071, /* A1 = -1.408203 */
10063 -32489, /* A2 = 0.991516 */
10064 -293, /* B2 = -0.008965 */
10065 0, /* B1 = 0.000000 */
10066 293, /* B0 = 0.008965 */
10067 22951, /* A1 = -1.400818 */
10068 -32655, /* A2 = 0.996582 */
10069 5689, /* B2 = 0.173645 */
10070 -3951, /* B1 = -0.241150 */
10071 5689, /* B0 = 0.173645 */
10072 23307, /* A1 = -1.422607 */
10073 -32657, /* A2 = 0.996613 */
10074 18692, /* B2 = 0.570435 */
10075 -13447, /* B1 = -0.820770 */
10076 18692, /* B0 = 0.570435 */
10077 5, /* Internal filter scaling */
10078 159, /* Minimum in-band energy threshold */
10079 21, /* 21/32 in-band to broad-band ratio */
10080 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10081 },
10082 { /* f1020 */
10083 22701, /* A1 = -1.385620 */
10084 -32474, /* A2 = 0.991058 */
10085 -292, /* B2 = -0.008933 */
10086 0, /*163840 , B1 = 10.000000 */
10087 292, /* B0 = 0.008933 */
10088 22564, /* A1 = -1.377258 */
10089 -32655, /* A2 = 0.996552 */
10090 20756, /* B2 = 0.633423 */
10091 -14176, /* B1 = -0.865295 */
10092 20756, /* B0 = 0.633423 */
10093 22960, /* A1 = -1.401428 */
10094 -32657, /* A2 = 0.996613 */
10095 6520, /* B2 = 0.198990 */
10096 -4619, /* B1 = -0.281937 */
10097 6520, /* B0 = 0.198990 */
10098 5, /* Internal filter scaling */
10099 159, /* Minimum in-band energy threshold */
10100 21, /* 21/32 in-band to broad-band ratio */
10101 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10102 },
10103 { /* f1050 */
10104 22142, /* A1 = -1.351501 */
10105 -32474, /* A2 = 0.991058 */
10106 -147, /* B2 = -0.004493 */
10107 0, /* B1 = 0.000000 */
10108 147, /* B0 = 0.004493 */
10109 22000, /* A1 = -1.342834 */
10110 -32655, /* A2 = 0.996552 */
10111 15379, /* B2 = 0.469360 */
10112 -10237, /* B1 = -0.624847 */
10113 15379, /* B0 = 0.469360 */
10114 22406, /* A1 = -1.367554 */
10115 -32657, /* A2 = 0.996613 */
10116 17491, /* B2 = 0.533783 */
10117 -12096, /* B1 = -0.738312 */
10118 17491, /* B0 = 0.533783 */
10119 5, /* Internal filter scaling */
10120 159, /* Minimum in-band energy threshold */
10121 21, /* 21/32 in-band to broad-band ratio */
10122 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10123 },
10124 { /* f1100_1750[] */
10125 12973, /* A1 = 0.79184 */
10126 -24916, /* A2 = -0.760376 */
10127 6655, /* B2 = 0.203102 */
10128 367, /* B1 = 0.0224 */
10129 6657, /* B0 = 0.203171 */
10130 5915, /* A1 = 0.361053 */
10131 -29560, /* A2 = -0.90213 */
10132 -7777, /* B2 = -0.23735 */
10133 0, /* B1 = 0 */
10134 7777, /* B0 = 0.23735 */
10135 20510, /* A1 = 1.251892 */
10136 -30260, /* A2 = -0.923462 */
10137 26662, /* B2 = 0.81366 */
10138 -20573, /* B1 = -1.255737 */
10139 26668, /* B0 = 0.813843 */
10140 7, /* Internal filter scaling */
10141 159, /* Minimum in-band energy threshold */
10142 21, /* 21/32 in-band to broad-band ratio */
10143 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10144 },
10145 { /* f1140 */
10146 20392, /* A1 = -1.244629 */
10147 -32460, /* A2 = 0.990601 */
10148 -270, /* B2 = -0.008240 */
10149 0, /* B1 = 0.000000 */
10150 270, /* B0 = 0.008240 */
10151 20218, /* A1 = -1.234009 */
10152 -32655, /* A2 = 0.996582 */
10153 21337, /* B2 = 0.651154 */
10154 -13044, /* B1 = -0.796143 */
10155 21337, /* B0 = 0.651154 */
10156 20684, /* A1 = -1.262512 */
10157 -32657, /* A2 = 0.996643 */
10158 8572, /* B2 = 0.261612 */
10159 -5476, /* B1 = -0.334244 */
10160 8572, /* B0 = 0.261612 */
10161 5, /* Internal filter scaling */
10162 159, /* Minimum in-band energy threshold */
10163 21, /* 21/32 in-band to broad-band ratio */
10164 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10165 },
10166 { /* f1200 */
10167 19159, /* A1 = -1.169373 */
10168 -32456, /* A2 = 0.990509 */
10169 -335, /* B2 = -0.010252 */
10170 0, /* B1 = 0.000000 */
10171 335, /* B0 = 0.010252 */
10172 18966, /* A1 = -1.157593 */
10173 -32661, /* A2 = 0.996735 */
10174 6802, /* B2 = 0.207588 */
10175 -3900, /* B1 = -0.238098 */
10176 6802, /* B0 = 0.207588 */
10177 19467, /* A1 = -1.188232 */
10178 -32661, /* A2 = 0.996765 */
10179 25035, /* B2 = 0.764008 */
10180 -15049, /* B1 = -0.918579 */
10181 25035, /* B0 = 0.764008 */
10182 5, /* Internal filter scaling */
10183 159, /* Minimum in-band energy threshold */
10184 21, /* 21/32 in-band to broad-band ratio */
10185 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10186 },
10187 { /* f1209 */
10188 18976, /* A1 = -1.158264 */
10189 -32439, /* A2 = 0.989990 */
10190 -183, /* B2 = -0.005588 */
10191 0, /* B1 = 0.000000 */
10192 183, /* B0 = 0.005588 */
10193 18774, /* A1 = -1.145874 */
10194 -32650, /* A2 = 0.996429 */
10195 15468, /* B2 = 0.472076 */
10196 -8768, /* B1 = -0.535217 */
10197 15468, /* B0 = 0.472076 */
10198 19300, /* A1 = -1.177979 */
10199 -32652, /* A2 = 0.996490 */
10200 19840, /* B2 = 0.605499 */
10201 -11842, /* B1 = -0.722809 */
10202 19840, /* B0 = 0.605499 */
10203 5, /* Internal filter scaling */
10204 159, /* Minimum in-band energy threshold */
10205 21, /* 21/32 in-band to broad-band ratio */
10206 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10207 },
10208 { /* f1330 */
10209 16357, /* A1 = -0.998413 */
10210 -32368, /* A2 = 0.987793 */
10211 -217, /* B2 = -0.006652 */
10212 0, /* B1 = 0.000000 */
10213 217, /* B0 = 0.006652 */
10214 16107, /* A1 = -0.983126 */
10215 -32601, /* A2 = 0.994904 */
10216 11602, /* B2 = 0.354065 */
10217 -5555, /* B1 = -0.339111 */
10218 11602, /* B0 = 0.354065 */
10219 16722, /* A1 = -1.020630 */
10220 -32603, /* A2 = 0.994965 */
10221 15574, /* B2 = 0.475311 */
10222 -8176, /* B1 = -0.499069 */
10223 15574, /* B0 = 0.475311 */
10224 5, /* Internal filter scaling */
10225 159, /* Minimum in-band energy threshold */
10226 21, /* 21/32 in-band to broad-band ratio */
10227 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10228 },
10229 { /* f1336 */
10230 16234, /* A1 = -0.990875 */
10231 32404, /* A2 = -0.988922 */
10232 -193, /* B2 = -0.005908 */
10233 0, /* B1 = 0.000000 */
10234 193, /* B0 = 0.005908 */
10235 15986, /* A1 = -0.975769 */
10236 -32632, /* A2 = 0.995880 */
10237 18051, /* B2 = 0.550903 */
10238 -8658, /* B1 = -0.528473 */
10239 18051, /* B0 = 0.550903 */
10240 16591, /* A1 = -1.012695 */
10241 -32634, /* A2 = 0.995941 */
10242 15736, /* B2 = 0.480240 */
10243 -8125, /* B1 = -0.495926 */
10244 15736, /* B0 = 0.480240 */
10245 5, /* Internal filter scaling */
10246 159, /* Minimum in-band energy threshold */
10247 21, /* 21/32 in-band to broad-band ratio */
10248 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10249 },
10250 { /* f1366 */
10251 15564, /* A1 = -0.949982 */
10252 -32404, /* A2 = 0.988922 */
10253 -269, /* B2 = -0.008216 */
10254 0, /* B1 = 0.000000 */
10255 269, /* B0 = 0.008216 */
10256 15310, /* A1 = -0.934479 */
10257 -32632, /* A2 = 0.995880 */
10258 10815, /* B2 = 0.330063 */
10259 -4962, /* B1 = -0.302887 */
10260 10815, /* B0 = 0.330063 */
10261 15924, /* A1 = -0.971924 */
10262 -32634, /* A2 = 0.995941 */
10263 18880, /* B2 = 0.576172 */
10264 -9364, /* B1 = -0.571594 */
10265 18880, /* B0 = 0.576172 */
10266 5, /* Internal filter scaling */
10267 159, /* Minimum in-band energy threshold */
10268 21, /* 21/32 in-band to broad-band ratio */
10269 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10270 },
10271 { /* f1380 */
10272 15247, /* A1 = -0.930603 */
10273 -32397, /* A2 = 0.988708 */
10274 -244, /* B2 = -0.007451 */
10275 0, /* B1 = 0.000000 */
10276 244, /* B0 = 0.007451 */
10277 14989, /* A1 = -0.914886 */
10278 -32627, /* A2 = 0.995697 */
10279 18961, /* B2 = 0.578644 */
10280 -8498, /* B1 = -0.518707 */
10281 18961, /* B0 = 0.578644 */
10282 15608, /* A1 = -0.952667 */
10283 -32628, /* A2 = 0.995758 */
10284 11145, /* B2 = 0.340134 */
10285 -5430, /* B1 = -0.331467 */
10286 11145, /* B0 = 0.340134 */
10287 5, /* Internal filter scaling */
10288 159, /* Minimum in-band energy threshold */
10289 21, /* 21/32 in-band to broad-band ratio */
10290 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10291 },
10292 { /* f1400 */
10293 14780, /* A1 = -0.902130 */
10294 -32393, /* A2 = 0.988586 */
10295 -396, /* B2 = -0.012086 */
10296 0, /* B1 = 0.000000 */
10297 396, /* B0 = 0.012086 */
10298 14510, /* A1 = -0.885651 */
10299 -32630, /* A2 = 0.995819 */
10300 6326, /* B2 = 0.193069 */
10301 -2747, /* B1 = -0.167671 */
10302 6326, /* B0 = 0.193069 */
10303 15154, /* A1 = -0.924957 */
10304 -32632, /* A2 = 0.995850 */
10305 23235, /* B2 = 0.709076 */
10306 -10983, /* B1 = -0.670380 */
10307 23235, /* B0 = 0.709076 */
10308 5, /* Internal filter scaling */
10309 159, /* Minimum in-band energy threshold */
10310 21, /* 21/32 in-band to broad-band ratio */
10311 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10312 },
10313 { /* f1477 */
10314 13005, /* A1 = -0.793793 */
10315 -32368, /* A2 = 0.987823 */
10316 -500, /* B2 = -0.015265 */
10317 0, /* B1 = 0.000000 */
10318 500, /* B0 = 0.015265 */
10319 12708, /* A1 = -0.775665 */
10320 -32615, /* A2 = 0.995331 */
10321 11420, /* B2 = 0.348526 */
10322 -4306, /* B1 = -0.262833 */
10323 11420, /* B0 = 0.348526 */
10324 13397, /* A1 = -0.817688 */
10325 -32615, /* A2 = 0.995361 */
10326 9454, /* B2 = 0.288528 */
10327 -3981, /* B1 = -0.243027 */
10328 9454, /* B0 = 0.288528 */
10329 5, /* Internal filter scaling */
10330 159, /* Minimum in-band energy threshold */
10331 21, /* 21/32 in-band to broad-band ratio */
10332 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10333 },
10334 { /* f1600 */
10335 10046, /* A1 = -0.613190 */
10336 -32331, /* A2 = 0.986694 */
10337 -455, /* B2 = -0.013915 */
10338 0, /* B1 = 0.000000 */
10339 455, /* B0 = 0.013915 */
10340 9694, /* A1 = -0.591705 */
10341 -32601, /* A2 = 0.994934 */
10342 6023, /* B2 = 0.183815 */
10343 -1708, /* B1 = -0.104279 */
10344 6023, /* B0 = 0.183815 */
10345 10478, /* A1 = -0.639587 */
10346 -32603, /* A2 = 0.994965 */
10347 22031, /* B2 = 0.672333 */
10348 -7342, /* B1 = -0.448151 */
10349 22031, /* B0 = 0.672333 */
10350 5, /* Internal filter scaling */
10351 159, /* Minimum in-band energy threshold */
10352 21, /* 21/32 in-band to broad-band ratio */
10353 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10354 },
10355 { /* f1633_1638[] */
10356 9181, /* A1 = 0.560394 */
10357 -32256, /* A2 = -0.984375 */
10358 -556, /* B2 = -0.016975 */
10359 0, /* B1 = 0 */
10360 556, /* B0 = 0.016975 */
10361 8757, /* A1 = 0.534515 */
10362 -32574, /* A2 = -0.99408 */
10363 8443, /* B2 = 0.25769 */
10364 -2135, /* B1 = -0.130341 */
10365 8443, /* B0 = 0.25769 */
10366 9691, /* A1 = 0.591522 */
10367 -32574, /* A2 = -0.99411 */
10368 15446, /* B2 = 0.471375 */
10369 -4809, /* B1 = -0.293579 */
10370 15446, /* B0 = 0.471375 */
10371 7, /* Internal filter scaling */
10372 159, /* Minimum in-band energy threshold */
10373 21, /* 21/32 in-band to broad-band ratio */
10374 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10375 },
10376 { /* f1800 */
10377 5076, /* A1 = -0.309875 */
10378 -32304, /* A2 = 0.985840 */
10379 -508, /* B2 = -0.015503 */
10380 0, /* B1 = 0.000000 */
10381 508, /* B0 = 0.015503 */
10382 4646, /* A1 = -0.283600 */
10383 -32605, /* A2 = 0.995026 */
10384 6742, /* B2 = 0.205780 */
10385 -878, /* B1 = -0.053635 */
10386 6742, /* B0 = 0.205780 */
10387 5552, /* A1 = -0.338928 */
10388 -32605, /* A2 = 0.995056 */
10389 23667, /* B2 = 0.722260 */
10390 -4297, /* B1 = -0.262329 */
10391 23667, /* B0 = 0.722260 */
10392 5, /* Internal filter scaling */
10393 159, /* Minimum in-band energy threshold */
10394 21, /* 21/32 in-band to broad-band ratio */
10395 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10396 },
10397 { /* f1860 */
10398 3569, /* A1 = -0.217865 */
10399 -32292, /* A2 = 0.985504 */
10400 -239, /* B2 = -0.007322 */
10401 0, /* B1 = 0.000000 */
10402 239, /* B0 = 0.007322 */
10403 3117, /* A1 = -0.190277 */
10404 -32603, /* A2 = 0.994965 */
10405 18658, /* B2 = 0.569427 */
10406 -1557, /* B1 = -0.095032 */
10407 18658, /* B0 = 0.569427 */
10408 4054, /* A1 = -0.247437 */
10409 -32603, /* A2 = 0.994965 */
10410 18886, /* B2 = 0.576385 */
10411 -2566, /* B1 = -0.156647 */
10412 18886, /* B0 = 0.576385 */
10413 5, /* Internal filter scaling */
10414 159, /* Minimum in-band energy threshold */
10415 21, /* 21/32 in-band to broad-band ratio */
10416 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10417 },
10418 };
10419 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10420 {
10421 unsigned short cmd;
10422 int cnt, max;
10423
10424 if (jf->filter > 3) {
10425 return -1;
10426 }
10427 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10428
10429 return -1;
10430 if (!jf->enable) {
10431 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10432
10433 return -1;
10434 else
10435 return 0;
10436 } else {
10437 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10438
10439 return -1;
10440 /* Select the filter (f0 - f3) to use. */
10441 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10442 return -1;
10443 }
10444 if (jf->freq < 12 && jf->freq > 3) {
10445 /* Select the frequency for the selected filter. */
10446 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10447 return -1;
10448 } else if (jf->freq > 11) {
10449 /* We need to load a programmable filter set for undefined */
10450 /* frequencies. So we will point the filter to a programmable set. */
10451 /* Since there are only 4 filters and 4 programmable sets, we will */
10452 /* just point the filter to the same number set and program it for the */
10453 /* frequency we want. */
10454 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10455 return -1;
10456 if (j->ver.low != 0x12) {
10457 cmd = 0x515B;
10458 max = 19;
10459 } else {
10460 cmd = 0x515E;
10461 max = 15;
10462 }
10463 if (ixj_WriteDSPCommand(cmd, j))
10464 return -1;
10465 for (cnt = 0; cnt < max; cnt++) {
10466 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10467 return -1;
10468 }
10469 }
10470 j->filter_en[jf->filter] = jf->enable;
10471 return 0;
10472 }
10473
10474 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10475 {
10476 unsigned short cmd;
10477 int cnt, max;
10478 if (jfr->filter > 3) {
10479 return -1;
10480 }
10481 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10482 return -1;
10483
10484 if (!jfr->enable) {
10485 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10486 return -1;
10487 else
10488 return 0;
10489 } else {
10490 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10491 return -1;
10492 /* Select the filter (f0 - f3) to use. */
10493 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10494 return -1;
10495 }
10496 /* We need to load a programmable filter set for undefined */
10497 /* frequencies. So we will point the filter to a programmable set. */
10498 /* Since there are only 4 filters and 4 programmable sets, we will */
10499 /* just point the filter to the same number set and program it for the */
10500 /* frequency we want. */
10501 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10502 return -1;
10503 if (j->ver.low != 0x12) {
10504 cmd = 0x515B;
10505 max = 19;
10506 } else {
10507 cmd = 0x515E;
10508 max = 15;
10509 }
10510 if (ixj_WriteDSPCommand(cmd, j))
10511 return -1;
10512 for (cnt = 0; cnt < max; cnt++) {
10513 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10514 return -1;
10515 }
10516 j->filter_en[jfr->filter] = jfr->enable;
10517 return 0;
10518 }
10519
10520 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10521 {
10522 int freq0, freq1;
10523 unsigned short data;
10524 if (ti->freq0) {
10525 freq0 = ti->freq0;
10526 } else {
10527 freq0 = 0x7FFF;
10528 }
10529
10530 if (ti->freq1) {
10531 freq1 = ti->freq1;
10532 } else {
10533 freq1 = 0x7FFF;
10534 }
10535
10536 if(ti->tone_index > 12 && ti->tone_index < 28)
10537 {
10538 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10539 return -1;
10540 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10541 return -1;
10542 data = freq0;
10543 if (ixj_WriteDSPCommand(data, j))
10544 return -1;
10545 data = freq1;
10546 if (ixj_WriteDSPCommand(data, j))
10547 return -1;
10548 }
10549 return freq0;
10550 }
10551
linux-next