projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/sam/sparc
[deliverable/linux.git] / drivers / telephony / ixj.c
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * $Log: ixj.c,v $
46 *
47 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
48 * Audit some copy_*_user and minor cleanup.
49 *
50 * Revision 4.7 2001/08/13 06:19:33 craigs
51 * Added additional changes from Alan Cox and John Anderson for
52 * 2.2 to 2.4 cleanup and bounds checking
53 *
54 * Revision 4.6 2001/08/13 01:05:05 craigs
55 * Really fixed PHONE_QUERY_CODEC problem this time
56 *
57 * Revision 4.5 2001/08/13 00:11:03 craigs
58 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
59 *
60 * Revision 4.4 2001/08/07 07:58:12 craigs
61 * Changed back to three digit version numbers
62 * Added tagbuild target to allow automatic and easy tagging of versions
63 *
64 * Revision 4.3 2001/08/07 07:24:47 craigs
65 * Added ixj-ver.h to allow easy configuration management of driver
66 * Added display of version number in /prox/ixj
67 *
68 * Revision 4.2 2001/08/06 07:07:19 craigs
69 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
70 * behaviour of returning int rather than short *
71 *
72 * Revision 4.1 2001/08/05 00:17:37 craigs
73 * More changes for correct PCMCIA installation
74 * Start of changes for backward Linux compatibility
75 *
76 * Revision 4.0 2001/08/04 12:33:12 craigs
77 * New version using GNU autoconf
78 *
79 * Revision 3.105 2001/07/20 23:14:32 eokerson
80 * More work on CallerID generation when using ring cadences.
81 *
82 * Revision 3.104 2001/07/06 01:33:55 eokerson
83 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
84 *
85 * Revision 3.103 2001/07/05 19:20:16 eokerson
86 * Updated HOWTO
87 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
88 *
89 * Revision 3.102 2001/07/03 23:51:21 eokerson
90 * Un-mute mic on Internet LineJACK when in speakerphone mode.
91 *
92 * Revision 3.101 2001/07/02 19:26:56 eokerson
93 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
94 *
95 * Revision 3.100 2001/07/02 19:18:27 eokerson
96 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
97 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
98 * Fixed speaker mode on Internet LineJACK.
99 *
100 * Revision 3.99 2001/05/09 14:11:16 eokerson
101 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
102 *
103 * Revision 3.98 2001/05/08 19:55:33 eokerson
104 * Fixed POTS hookstate detection while it is connected to PSTN port.
105 *
106 * Revision 3.97 2001/05/08 00:01:04 eokerson
107 * Fixed kernel oops when sending caller ID data.
108 *
109 * Revision 3.96 2001/05/04 23:09:30 eokerson
110 * Now uses one kernel timer for each card, instead of one for the entire driver.
111 *
112 * Revision 3.95 2001/04/25 22:06:47 eokerson
113 * Fixed squawking at beginning of some G.723.1 calls.
114 *
115 * Revision 3.94 2001/04/03 23:42:00 eokerson
116 * Added linear volume ioctls
117 * Added raw filter load ioctl
118 *
119 * Revision 3.93 2001/02/27 01:00:06 eokerson
120 * Fixed blocking in CallerID.
121 * Reduced size of ixj structure for smaller driver footprint.
122 *
123 * Revision 3.92 2001/02/20 22:02:59 eokerson
124 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
125 * Improved PSTN ring detection.
126 * Fixed wink generation on POTS ports.
127 *
128 * Revision 3.91 2001/02/13 00:55:44 eokerson
129 * Turn AEC back on after changing frame sizes.
130 *
131 * Revision 3.90 2001/02/12 16:42:00 eokerson
132 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
133 *
134 * Revision 3.89 2001/02/12 15:41:16 eokerson
135 * Fix from Artis Kugevics - Tone gains were not being set correctly.
136 *
137 * Revision 3.88 2001/02/05 23:25:42 eokerson
138 * Fixed lockup bugs with deregister.
139 *
140 * Revision 3.87 2001/01/29 21:00:39 eokerson
141 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
142 * Updated copyright date.
143 *
144 * Revision 3.86 2001/01/23 23:53:46 eokerson
145 * Fixes to G.729 compatibility.
146 *
147 * Revision 3.85 2001/01/23 21:30:36 eokerson
148 * Added verbage about cards supported.
149 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
150 *
151 * Revision 3.84 2001/01/22 23:32:10 eokerson
152 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
153 *
154 * Revision 3.83 2001/01/19 14:51:41 eokerson
155 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
156 *
157 * Revision 3.82 2001/01/19 00:34:49 eokerson
158 * Added verbosity to write overlap errors.
159 *
160 * Revision 3.81 2001/01/18 23:56:54 eokerson
161 * Fixed PSTN line test functions.
162 *
163 * Revision 3.80 2001/01/18 22:29:27 eokerson
164 * Updated AEC/AGC values for different cards.
165 *
166 * Revision 3.79 2001/01/17 02:58:54 eokerson
167 * Fixed AEC reset after Caller ID.
168 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
169 *
170 * Revision 3.78 2001/01/16 19:43:09 eokerson
171 * Added support for Linux 2.4.x kernels.
172 *
173 * Revision 3.77 2001/01/09 04:00:52 eokerson
174 * Linetest will now test the line, even if it has previously succeded.
175 *
176 * Revision 3.76 2001/01/08 19:27:00 eokerson
177 * Fixed problem with standard cable on Internet PhoneCARD.
178 *
179 * Revision 3.75 2000/12/22 16:52:14 eokerson
180 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
181 *
182 * Revision 3.74 2000/12/08 22:41:50 eokerson
183 * Added capability for G729B.
184 *
185 * Revision 3.73 2000/12/07 23:35:16 eokerson
186 * Added capability to have different ring pattern before CallerID data.
187 * Added hookstate checks in CallerID routines to stop FSK.
188 *
189 * Revision 3.72 2000/12/06 19:31:31 eokerson
190 * Modified signal behavior to only send one signal per event.
191 *
192 * Revision 3.71 2000/12/06 03:23:08 eokerson
193 * Fixed CallerID on Call Waiting.
194 *
195 * Revision 3.70 2000/12/04 21:29:37 eokerson
196 * Added checking to Smart Cable gain functions.
197 *
198 * Revision 3.69 2000/12/04 21:05:20 eokerson
199 * Changed ixjdebug levels.
200 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
201 *
202 * Revision 3.68 2000/12/04 00:17:21 craigs
203 * Changed mixer voice gain to +6dB rather than 0dB
204 *
205 * Revision 3.67 2000/11/30 21:25:51 eokerson
206 * Fixed write signal errors.
207 *
208 * Revision 3.66 2000/11/29 22:42:44 eokerson
209 * Fixed PSTN ring detect problems.
210 *
211 * Revision 3.65 2000/11/29 07:31:55 craigs
212 * Added new 425Hz filter co-efficients
213 * Added card-specific DTMF prescaler initialisation
214 *
215 * Revision 3.64 2000/11/28 14:03:32 craigs
216 * Changed certain mixer initialisations to be 0dB rather than 12dB
217 * Added additional information to /proc/ixj
218 *
219 * Revision 3.63 2000/11/28 11:38:41 craigs
220 * Added display of AEC modes in AUTO and AGC mode
221 *
222 * Revision 3.62 2000/11/28 04:05:44 eokerson
223 * Improved PSTN ring detection routine.
224 *
225 * Revision 3.61 2000/11/27 21:53:12 eokerson
226 * Fixed flash detection.
227 *
228 * Revision 3.60 2000/11/27 15:57:29 eokerson
229 * More work on G.729 load routines.
230 *
231 * Revision 3.59 2000/11/25 21:55:12 eokerson
232 * Fixed errors in G.729 load routine.
233 *
234 * Revision 3.58 2000/11/25 04:08:29 eokerson
235 * Added board locks around G.729 and TS85 load routines.
236 *
237 * Revision 3.57 2000/11/24 05:35:17 craigs
238 * Added ability to retrieve mixer values on LineJACK
239 * Added complete initialisation of all mixer values at startup
240 * Fixed spelling mistake
241 *
242 * Revision 3.56 2000/11/23 02:52:11 robertj
243 * Added cvs change log keyword.
244 * Fixed bug in capabilities list when using G.729 module.
245 *
246 */
247
248 #include "ixj-ver.h"
249
250 #define PERFMON_STATS
251 #define IXJDEBUG 0
252 #define MAXRINGS 5
253
254 #include <linux/module.h>
255
256 #include <linux/init.h>
257 #include <linux/sched.h>
258 #include <linux/kernel.h> /* printk() */
259 #include <linux/fs.h> /* everything... */
260 #include <linux/errno.h> /* error codes */
261 #include <linux/slab.h>
262 #include <linux/mm.h>
263 #include <linux/ioport.h>
264 #include <linux/interrupt.h>
265 #include <linux/proc_fs.h>
266 #include <linux/poll.h>
267 #include <linux/timer.h>
268 #include <linux/delay.h>
269 #include <linux/pci.h>
270
271 #include <asm/io.h>
272 #include <asm/uaccess.h>
273
274 #include <linux/isapnp.h>
275
276 #include "ixj.h"
277
278 #define TYPE(inode) (iminor(inode) >> 4)
279 #define NUM(inode) (iminor(inode) & 0xf)
280
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 module_param(ixjdebug, int, 0);
286
287 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
288 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
289 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
290 { }
291 };
292
293 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
294
295 /************************************************************************
296 *
297 * ixjdebug meanings are now bit mapped instead of level based
298 * Values can be or'ed together to turn on multiple messages
299 *
300 * bit 0 (0x0001) = any failure
301 * bit 1 (0x0002) = general messages
302 * bit 2 (0x0004) = POTS ringing related
303 * bit 3 (0x0008) = PSTN events
304 * bit 4 (0x0010) = PSTN Cadence state details
305 * bit 5 (0x0020) = Tone detection triggers
306 * bit 6 (0x0040) = Tone detection cadence details
307 * bit 7 (0x0080) = ioctl tracking
308 * bit 8 (0x0100) = signal tracking
309 * bit 9 (0x0200) = CallerID generation details
310 *
311 ************************************************************************/
312
313 #ifdef IXJ_DYN_ALLOC
314
315 static IXJ *ixj[IXJMAX];
316 #define get_ixj(b) ixj[(b)]
317
318 /*
319 * Allocate a free IXJ device
320 */
321
322 static IXJ *ixj_alloc()
323 {
324 for(cnt=0; cnt<IXJMAX; cnt++)
325 {
326 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
327 {
328 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
329 if (j == NULL)
330 return NULL;
331 ixj[cnt] = j;
332 return j;
333 }
334 }
335 return NULL;
336 }
337
338 static void ixj_fsk_free(IXJ *j)
339 {
340 kfree(j->fskdata);
341 j->fskdata = NULL;
342 }
343
344 static void ixj_fsk_alloc(IXJ *j)
345 {
346 if(!j->fskdata) {
347 j->fskdata = kmalloc(8000, GFP_KERNEL);
348 if (!j->fskdata) {
349 if(ixjdebug & 0x0200) {
350 printk("IXJ phone%d - allocate failed\n", j->board);
351 }
352 return;
353 } else {
354 j->fsksize = 8000;
355 if(ixjdebug & 0x0200) {
356 printk("IXJ phone%d - allocate succeded\n", j->board);
357 }
358 }
359 }
360 }
361
362 #else
363
364 static IXJ ixj[IXJMAX];
365 #define get_ixj(b) (&ixj[(b)])
366
367 /*
368 * Allocate a free IXJ device
369 */
370
371 static IXJ *ixj_alloc(void)
372 {
373 int cnt;
374 for(cnt=0; cnt<IXJMAX; cnt++) {
375 if(!ixj[cnt].DSPbase)
376 return &ixj[cnt];
377 }
378 return NULL;
379 }
380
381 static inline void ixj_fsk_free(IXJ *j) {;}
382
383 static inline void ixj_fsk_alloc(IXJ *j)
384 {
385 j->fsksize = 8000;
386 }
387
388 #endif
389
390 #ifdef PERFMON_STATS
391 #define ixj_perfmon(x) ((x)++)
392 #else
393 #define ixj_perfmon(x) do { } while(0)
394 #endif
395
396 static int ixj_convert_loaded;
397
398 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
399
400 /************************************************************************
401 *
402 * These are function definitions to allow external modules to register
403 * enhanced functionality call backs.
404 *
405 ************************************************************************/
406
407 static int Stub(IXJ * J, unsigned long arg)
408 {
409 return 0;
410 }
411
412 static IXJ_REGFUNC ixj_PreRead = &Stub;
413 static IXJ_REGFUNC ixj_PostRead = &Stub;
414 static IXJ_REGFUNC ixj_PreWrite = &Stub;
415 static IXJ_REGFUNC ixj_PostWrite = &Stub;
416
417 static void ixj_read_frame(IXJ *j);
418 static void ixj_write_frame(IXJ *j);
419 static void ixj_init_timer(IXJ *j);
420 static void ixj_add_timer(IXJ * j);
421 static void ixj_timeout(unsigned long ptr);
422 static int read_filters(IXJ *j);
423 static int LineMonitor(IXJ *j);
424 static int ixj_fasync(int fd, struct file *, int mode);
425 static int ixj_set_port(IXJ *j, int arg);
426 static int ixj_set_pots(IXJ *j, int arg);
427 static int ixj_hookstate(IXJ *j);
428 static int ixj_record_start(IXJ *j);
429 static void ixj_record_stop(IXJ *j);
430 static void set_rec_volume(IXJ *j, int volume);
431 static int get_rec_volume(IXJ *j);
432 static int set_rec_codec(IXJ *j, int rate);
433 static void ixj_vad(IXJ *j, int arg);
434 static int ixj_play_start(IXJ *j);
435 static void ixj_play_stop(IXJ *j);
436 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
437 static int ixj_set_tone_off(unsigned short, IXJ *j);
438 static int ixj_play_tone(IXJ *j, char tone);
439 static void ixj_aec_start(IXJ *j, int level);
440 static int idle(IXJ *j);
441 static void ixj_ring_on(IXJ *j);
442 static void ixj_ring_off(IXJ *j);
443 static void aec_stop(IXJ *j);
444 static void ixj_ringback(IXJ *j);
445 static void ixj_busytone(IXJ *j);
446 static void ixj_dialtone(IXJ *j);
447 static void ixj_cpt_stop(IXJ *j);
448 static char daa_int_read(IXJ *j);
449 static char daa_CR_read(IXJ *j, int cr);
450 static int daa_set_mode(IXJ *j, int mode);
451 static int ixj_linetest(IXJ *j);
452 static int ixj_daa_write(IXJ *j);
453 static int ixj_daa_cid_read(IXJ *j);
454 static void DAA_Coeff_US(IXJ *j);
455 static void DAA_Coeff_UK(IXJ *j);
456 static void DAA_Coeff_France(IXJ *j);
457 static void DAA_Coeff_Germany(IXJ *j);
458 static void DAA_Coeff_Australia(IXJ *j);
459 static void DAA_Coeff_Japan(IXJ *j);
460 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
461 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
462 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
463 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
464 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
465 /* Serial Control Interface funtions */
466 static int SCI_Control(IXJ *j, int control);
467 static int SCI_Prepare(IXJ *j);
468 static int SCI_WaitHighSCI(IXJ *j);
469 static int SCI_WaitLowSCI(IXJ *j);
470 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
471 static int ixj_PCcontrol_wait(IXJ *j);
472 static void ixj_pre_cid(IXJ *j);
473 static void ixj_write_cid(IXJ *j);
474 static void ixj_write_cid_bit(IXJ *j, int bit);
475 static int set_base_frame(IXJ *j, int size);
476 static int set_play_codec(IXJ *j, int rate);
477 static void set_rec_depth(IXJ *j, int depth);
478 static int ixj_mixer(long val, IXJ *j);
479
480 /************************************************************************
481 CT8020/CT8021 Host Programmers Model
482 Host address Function Access
483 DSPbase +
484 0-1 Aux Software Status Register (reserved) Read Only
485 2-3 Software Status Register Read Only
486 4-5 Aux Software Control Register (reserved) Read Write
487 6-7 Software Control Register Read Write
488 8-9 Hardware Status Register Read Only
489 A-B Hardware Control Register Read Write
490 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
491 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
492 ************************************************************************/
493
494 static inline void ixj_read_HSR(IXJ *j)
495 {
496 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
497 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
498 }
499
500 static inline int IsControlReady(IXJ *j)
501 {
502 ixj_read_HSR(j);
503 return j->hsr.bits.controlrdy ? 1 : 0;
504 }
505
506 static inline int IsPCControlReady(IXJ *j)
507 {
508 j->pccr1.byte = inb_p(j->XILINXbase + 3);
509 return j->pccr1.bits.crr ? 1 : 0;
510 }
511
512 static inline int IsStatusReady(IXJ *j)
513 {
514 ixj_read_HSR(j);
515 return j->hsr.bits.statusrdy ? 1 : 0;
516 }
517
518 static inline int IsRxReady(IXJ *j)
519 {
520 ixj_read_HSR(j);
521 ixj_perfmon(j->rxreadycheck);
522 return j->hsr.bits.rxrdy ? 1 : 0;
523 }
524
525 static inline int IsTxReady(IXJ *j)
526 {
527 ixj_read_HSR(j);
528 ixj_perfmon(j->txreadycheck);
529 return j->hsr.bits.txrdy ? 1 : 0;
530 }
531
532 static inline void set_play_volume(IXJ *j, int volume)
533 {
534 if (ixjdebug & 0x0002)
535 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
536 ixj_WriteDSPCommand(0xCF02, j);
537 ixj_WriteDSPCommand(volume, j);
538 }
539
540 static int set_play_volume_linear(IXJ *j, int volume)
541 {
542 int newvolume, dspplaymax;
543
544 if (ixjdebug & 0x0002)
545 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
546 if(volume > 100 || volume < 0) {
547 return -1;
548 }
549
550 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
551 switch (j->cardtype) {
552 case QTI_PHONEJACK:
553 dspplaymax = 0x380;
554 break;
555 case QTI_LINEJACK:
556 if(j->port == PORT_PSTN) {
557 dspplaymax = 0x48;
558 } else {
559 dspplaymax = 0x100;
560 }
561 break;
562 case QTI_PHONEJACK_LITE:
563 dspplaymax = 0x380;
564 break;
565 case QTI_PHONEJACK_PCI:
566 dspplaymax = 0x6C;
567 break;
568 case QTI_PHONECARD:
569 dspplaymax = 0x50;
570 break;
571 default:
572 return -1;
573 }
574 newvolume = (dspplaymax * volume) / 100;
575 set_play_volume(j, newvolume);
576 return 0;
577 }
578
579 static inline void set_play_depth(IXJ *j, int depth)
580 {
581 if (depth > 60)
582 depth = 60;
583 if (depth < 0)
584 depth = 0;
585 ixj_WriteDSPCommand(0x5280 + depth, j);
586 }
587
588 static inline int get_play_volume(IXJ *j)
589 {
590 ixj_WriteDSPCommand(0xCF00, j);
591 return j->ssr.high << 8 | j->ssr.low;
592 }
593
594 static int get_play_volume_linear(IXJ *j)
595 {
596 int volume, newvolume, dspplaymax;
597
598 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
599 switch (j->cardtype) {
600 case QTI_PHONEJACK:
601 dspplaymax = 0x380;
602 break;
603 case QTI_LINEJACK:
604 if(j->port == PORT_PSTN) {
605 dspplaymax = 0x48;
606 } else {
607 dspplaymax = 0x100;
608 }
609 break;
610 case QTI_PHONEJACK_LITE:
611 dspplaymax = 0x380;
612 break;
613 case QTI_PHONEJACK_PCI:
614 dspplaymax = 0x6C;
615 break;
616 case QTI_PHONECARD:
617 dspplaymax = 100;
618 break;
619 default:
620 return -1;
621 }
622 volume = get_play_volume(j);
623 newvolume = (volume * 100) / dspplaymax;
624 if(newvolume > 100)
625 newvolume = 100;
626 return newvolume;
627 }
628
629 static inline BYTE SLIC_GetState(IXJ *j)
630 {
631 if (j->cardtype == QTI_PHONECARD) {
632 j->pccr1.byte = 0;
633 j->psccr.bits.dev = 3;
634 j->psccr.bits.rw = 1;
635 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
636 ixj_PCcontrol_wait(j);
637 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
638 ixj_PCcontrol_wait(j);
639 if (j->pslic.bits.powerdown)
640 return PLD_SLIC_STATE_OC;
641 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
642 return PLD_SLIC_STATE_ACTIVE;
643 else
644 return PLD_SLIC_STATE_RINGING;
645 } else {
646 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
647 }
648 return j->pld_slicr.bits.state;
649 }
650
651 static bool SLIC_SetState(BYTE byState, IXJ *j)
652 {
653 bool fRetVal = false;
654
655 if (j->cardtype == QTI_PHONECARD) {
656 if (j->flags.pcmciasct) {
657 switch (byState) {
658 case PLD_SLIC_STATE_TIPOPEN:
659 case PLD_SLIC_STATE_OC:
660 j->pslic.bits.powerdown = 1;
661 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
662 fRetVal = true;
663 break;
664 case PLD_SLIC_STATE_RINGING:
665 if (j->readers || j->writers) {
666 j->pslic.bits.powerdown = 0;
667 j->pslic.bits.ring0 = 1;
668 j->pslic.bits.ring1 = 0;
669 fRetVal = true;
670 }
671 break;
672 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
673
674 case PLD_SLIC_STATE_STANDBY:
675 case PLD_SLIC_STATE_ACTIVE:
676 if (j->readers || j->writers) {
677 j->pslic.bits.powerdown = 0;
678 } else {
679 j->pslic.bits.powerdown = 1;
680 }
681 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
682 fRetVal = true;
683 break;
684 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
685
686 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
687
688 default:
689 fRetVal = false;
690 break;
691 }
692 j->psccr.bits.dev = 3;
693 j->psccr.bits.rw = 0;
694 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
695 ixj_PCcontrol_wait(j);
696 }
697 } else {
698 /* Set the C1, C2, C3 & B2EN signals. */
699 switch (byState) {
700 case PLD_SLIC_STATE_OC:
701 j->pld_slicw.bits.c1 = 0;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 0;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
706 fRetVal = true;
707 break;
708 case PLD_SLIC_STATE_RINGING:
709 j->pld_slicw.bits.c1 = 1;
710 j->pld_slicw.bits.c2 = 0;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 1;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
714 fRetVal = true;
715 break;
716 case PLD_SLIC_STATE_ACTIVE:
717 j->pld_slicw.bits.c1 = 0;
718 j->pld_slicw.bits.c2 = 1;
719 j->pld_slicw.bits.c3 = 0;
720 j->pld_slicw.bits.b2en = 0;
721 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
722 fRetVal = true;
723 break;
724 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
725
726 j->pld_slicw.bits.c1 = 1;
727 j->pld_slicw.bits.c2 = 1;
728 j->pld_slicw.bits.c3 = 0;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
731 fRetVal = true;
732 break;
733 case PLD_SLIC_STATE_TIPOPEN:
734 j->pld_slicw.bits.c1 = 0;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 0;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
739 fRetVal = true;
740 break;
741 case PLD_SLIC_STATE_STANDBY:
742 j->pld_slicw.bits.c1 = 1;
743 j->pld_slicw.bits.c2 = 0;
744 j->pld_slicw.bits.c3 = 1;
745 j->pld_slicw.bits.b2en = 1;
746 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
747 fRetVal = true;
748 break;
749 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
750
751 j->pld_slicw.bits.c1 = 0;
752 j->pld_slicw.bits.c2 = 1;
753 j->pld_slicw.bits.c3 = 1;
754 j->pld_slicw.bits.b2en = 0;
755 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
756 fRetVal = true;
757 break;
758 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
759
760 j->pld_slicw.bits.c1 = 1;
761 j->pld_slicw.bits.c2 = 1;
762 j->pld_slicw.bits.c3 = 1;
763 j->pld_slicw.bits.b2en = 0;
764 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
765 fRetVal = true;
766 break;
767 default:
768 fRetVal = false;
769 break;
770 }
771 }
772
773 return fRetVal;
774 }
775
776 static int ixj_wink(IXJ *j)
777 {
778 BYTE slicnow;
779
780 slicnow = SLIC_GetState(j);
781
782 j->pots_winkstart = jiffies;
783 SLIC_SetState(PLD_SLIC_STATE_OC, j);
784
785 msleep(jiffies_to_msecs(j->winktime));
786
787 SLIC_SetState(slicnow, j);
788 return 0;
789 }
790
791 static void ixj_init_timer(IXJ *j)
792 {
793 init_timer(&j->timer);
794 j->timer.function = ixj_timeout;
795 j->timer.data = (unsigned long)j;
796 }
797
798 static void ixj_add_timer(IXJ *j)
799 {
800 j->timer.expires = jiffies + (hertz / samplerate);
801 add_timer(&j->timer);
802 }
803
804 static void ixj_tone_timeout(IXJ *j)
805 {
806 IXJ_TONE ti;
807
808 j->tone_state++;
809 if (j->tone_state == 3) {
810 j->tone_state = 0;
811 if (j->cadence_t) {
812 j->tone_cadence_state++;
813 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
814 switch (j->cadence_t->termination) {
815 case PLAY_ONCE:
816 ixj_cpt_stop(j);
817 break;
818 case REPEAT_LAST_ELEMENT:
819 j->tone_cadence_state--;
820 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
821 break;
822 case REPEAT_ALL:
823 j->tone_cadence_state = 0;
824 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
825 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
826 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
827 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
828 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
829 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
830 ixj_init_tone(j, &ti);
831 }
832 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
833 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
834 ixj_play_tone(j, j->cadence_t->ce[0].index);
835 break;
836 }
837 } else {
838 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
839 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
840 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
841 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
842 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
843 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
844 ixj_init_tone(j, &ti);
845 }
846 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
847 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
848 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
849 }
850 }
851 }
852 }
853
854 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
855 {
856 if(j->ixj_signals[event]) {
857 if(ixjdebug & 0x0100)
858 printk("Sending signal for event %d\n", event);
859 /* Send apps notice of change */
860 /* see config.h for macro definition */
861 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
862 }
863 }
864
865 static void ixj_pstn_state(IXJ *j)
866 {
867 int var;
868 union XOPXR0 XR0, daaint;
869
870 var = 10;
871
872 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
873 daaint.reg = 0;
874 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
875
876 j->pld_scrr.byte = inb_p(j->XILINXbase);
877 if (j->pld_scrr.bits.daaflag) {
878 daa_int_read(j);
879 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
880 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
881 daaint.bitreg.RING = 1;
882 if(ixjdebug & 0x0008) {
883 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
884 }
885 } else {
886 daa_set_mode(j, SOP_PU_RESET);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
890 daaint.bitreg.Caller_ID = 1;
891 j->pstn_cid_intr = 1;
892 j->pstn_cid_received = jiffies;
893 if(ixjdebug & 0x0008) {
894 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
895 }
896 }
897 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
898 daaint.bitreg.Cadence = 1;
899 if(ixjdebug & 0x0008) {
900 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
901 }
902 }
903 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
904 daaint.bitreg.VDD_OK = 1;
905 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
906 }
907 }
908 daa_CR_read(j, 1);
909 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)) {
910 daaint.bitreg.RMR = 1;
911 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
912 if(ixjdebug & 0x0008) {
913 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);
914 }
915 j->pstn_prev_rmr = j->pstn_last_rmr;
916 j->pstn_last_rmr = jiffies;
917 }
918 switch(j->daa_mode) {
919 case SOP_PU_SLEEP:
920 if (daaint.bitreg.RING) {
921 if (!j->flags.pstn_ringing) {
922 if (j->daa_mode != SOP_PU_RINGING) {
923 j->pstn_ring_int = jiffies;
924 daa_set_mode(j, SOP_PU_RINGING);
925 }
926 }
927 }
928 break;
929 case SOP_PU_RINGING:
930 if (daaint.bitreg.RMR) {
931 if (ixjdebug & 0x0008) {
932 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
933 }
934 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
935 j->flags.pstn_rmr = 1;
936 j->pstn_ring_start = jiffies;
937 j->pstn_ring_stop = 0;
938 j->ex.bits.pstn_ring = 0;
939 if (j->cadence_f[4].state == 0) {
940 j->cadence_f[4].state = 1;
941 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
942 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
943 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
944 } else if (j->cadence_f[4].state == 2) {
945 if((time_after(jiffies, j->cadence_f[4].off1min) &&
946 time_before(jiffies, j->cadence_f[4].off1max))) {
947 if (j->cadence_f[4].on2) {
948 j->cadence_f[4].state = 3;
949 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
950 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
951 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
952 } else {
953 j->cadence_f[4].state = 7;
954 }
955 } else {
956 if (ixjdebug & 0x0008) {
957 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
958 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
959 j->cadence_f[4].off1);
960 }
961 j->cadence_f[4].state = 0;
962 }
963 } else if (j->cadence_f[4].state == 4) {
964 if((time_after(jiffies, j->cadence_f[4].off2min) &&
965 time_before(jiffies, j->cadence_f[4].off2max))) {
966 if (j->cadence_f[4].on3) {
967 j->cadence_f[4].state = 5;
968 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
969 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
970 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
971 } else {
972 j->cadence_f[4].state = 7;
973 }
974 } else {
975 if (ixjdebug & 0x0008) {
976 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
977 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
978 j->cadence_f[4].off2);
979 }
980 j->cadence_f[4].state = 0;
981 }
982 } else if (j->cadence_f[4].state == 6) {
983 if((time_after(jiffies, j->cadence_f[4].off3min) &&
984 time_before(jiffies, j->cadence_f[4].off3max))) {
985 j->cadence_f[4].state = 7;
986 } else {
987 if (ixjdebug & 0x0008) {
988 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
989 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
990 j->cadence_f[4].off3);
991 }
992 j->cadence_f[4].state = 0;
993 }
994 } else {
995 j->cadence_f[4].state = 0;
996 }
997 } else { /* Falling edge of RMR */
998 j->pstn_ring_start = 0;
999 j->pstn_ring_stop = jiffies;
1000 if (j->cadence_f[4].state == 1) {
1001 if(!j->cadence_f[4].on1) {
1002 j->cadence_f[4].state = 7;
1003 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004 time_before(jiffies, j->cadence_f[4].on1max))) {
1005 if (j->cadence_f[4].off1) {
1006 j->cadence_f[4].state = 2;
1007 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010 } else {
1011 j->cadence_f[4].state = 7;
1012 }
1013 } else {
1014 if (ixjdebug & 0x0008) {
1015 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017 j->cadence_f[4].on1);
1018 }
1019 j->cadence_f[4].state = 0;
1020 }
1021 } else if (j->cadence_f[4].state == 3) {
1022 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023 time_before(jiffies, j->cadence_f[4].on2max))) {
1024 if (j->cadence_f[4].off2) {
1025 j->cadence_f[4].state = 4;
1026 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029 } else {
1030 j->cadence_f[4].state = 7;
1031 }
1032 } else {
1033 if (ixjdebug & 0x0008) {
1034 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036 j->cadence_f[4].on2);
1037 }
1038 j->cadence_f[4].state = 0;
1039 }
1040 } else if (j->cadence_f[4].state == 5) {
1041 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042 time_before(jiffies, j->cadence_f[4].on3max))) {
1043 if (j->cadence_f[4].off3) {
1044 j->cadence_f[4].state = 6;
1045 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048 } else {
1049 j->cadence_f[4].state = 7;
1050 }
1051 } else {
1052 j->cadence_f[4].state = 0;
1053 }
1054 } else {
1055 if (ixjdebug & 0x0008) {
1056 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058 j->cadence_f[4].on3);
1059 }
1060 j->cadence_f[4].state = 0;
1061 }
1062 }
1063 if (ixjdebug & 0x0010) {
1064 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065 }
1066 if (ixjdebug & 0x0010) {
1067 switch(j->cadence_f[4].state) {
1068 case 1:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071 break;
1072 case 2:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075 break;
1076 case 3:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079 break;
1080 case 4:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083 break;
1084 case 5:
1085 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087 break;
1088 case 6:
1089 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091 break;
1092 }
1093 }
1094 }
1095 if (j->cadence_f[4].state == 7) {
1096 j->cadence_f[4].state = 0;
1097 j->pstn_ring_stop = jiffies;
1098 j->ex.bits.pstn_ring = 1;
1099 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100 if(ixjdebug & 0x0008) {
1101 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102 }
1103 }
1104 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106 if(ixjdebug & 0x0008) {
1107 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110 }
1111 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112 daa_set_mode(j, SOP_PU_SLEEP);
1113 }
1114 outb_p(j->pld_scrw.byte, j->XILINXbase);
1115 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116 ixj_daa_cid_read(j);
1117 j->ex.bits.caller_id = 1;
1118 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119 j->pstn_cid_intr = 0;
1120 }
1121 if (daaint.bitreg.Cadence) {
1122 if(ixjdebug & 0x0008) {
1123 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124 }
1125 daa_set_mode(j, SOP_PU_SLEEP);
1126 j->ex.bits.pstn_ring = 0;
1127 }
1128 break;
1129 case SOP_PU_CONVERSATION:
1130 if (daaint.bitreg.VDD_OK) {
1131 if(!daaint.bitreg.SI_0) {
1132 if (!j->pstn_winkstart) {
1133 if(ixjdebug & 0x0008) {
1134 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135 }
1136 j->pstn_winkstart = jiffies;
1137 }
1138 } else {
1139 if (j->pstn_winkstart) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 j->pstn_winkstart = 0;
1144 }
1145 }
1146 }
1147 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148 if(ixjdebug & 0x0008) {
1149 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150 }
1151 daa_set_mode(j, SOP_PU_SLEEP);
1152 j->pstn_winkstart = 0;
1153 j->ex.bits.pstn_wink = 1;
1154 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155 }
1156 break;
1157 }
1158 }
1159
1160 static void ixj_timeout(unsigned long ptr)
1161 {
1162 int board;
1163 unsigned long jifon;
1164 IXJ *j = (IXJ *)ptr;
1165 board = j->board;
1166
1167 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168 ixj_perfmon(j->timerchecks);
1169 j->hookstate = ixj_hookstate(j);
1170 if (j->tone_state) {
1171 if (!(j->hookstate)) {
1172 ixj_cpt_stop(j);
1173 if (j->m_hook) {
1174 j->m_hook = 0;
1175 j->ex.bits.hookstate = 1;
1176 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177 }
1178 clear_bit(board, &j->busyflags);
1179 ixj_add_timer(j);
1180 return;
1181 }
1182 if (j->tone_state == 1)
1183 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184 else
1185 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187 if (j->tone_state == 1) {
1188 ixj_play_tone(j, j->tone_index);
1189 if (j->dsp.low == 0x20) {
1190 clear_bit(board, &j->busyflags);
1191 ixj_add_timer(j);
1192 return;
1193 }
1194 } else {
1195 ixj_play_tone(j, 0);
1196 if (j->dsp.low == 0x20) {
1197 clear_bit(board, &j->busyflags);
1198 ixj_add_timer(j);
1199 return;
1200 }
1201 }
1202 } else {
1203 ixj_tone_timeout(j);
1204 if (j->flags.dialtone) {
1205 ixj_dialtone(j);
1206 }
1207 if (j->flags.busytone) {
1208 ixj_busytone(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (j->flags.ringback) {
1216 ixj_ringback(j);
1217 if (j->dsp.low == 0x20) {
1218 clear_bit(board, &j->busyflags);
1219 ixj_add_timer(j);
1220 return;
1221 }
1222 }
1223 if (!j->tone_state) {
1224 ixj_cpt_stop(j);
1225 }
1226 }
1227 }
1228 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229 if (IsRxReady(j)) {
1230 ixj_read_frame(j);
1231 }
1232 if (IsTxReady(j)) {
1233 ixj_write_frame(j);
1234 }
1235 }
1236 if (j->flags.cringing) {
1237 if (j->hookstate & 1) {
1238 j->flags.cringing = 0;
1239 ixj_ring_off(j);
1240 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241 switch(j->cadence_f[5].state) {
1242 case 0:
1243 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245 if(ixjdebug & 0x0004) {
1246 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247 }
1248 ixj_ring_on(j);
1249 }
1250 j->cadence_f[5].state = 1;
1251 break;
1252 case 1:
1253 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255 if(ixjdebug & 0x0004) {
1256 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257 }
1258 ixj_ring_off(j);
1259 j->cadence_f[5].state = 2;
1260 }
1261 break;
1262 case 2:
1263 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264 if(ixjdebug & 0x0004) {
1265 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266 }
1267 ixj_ring_on(j);
1268 if (j->cadence_f[5].on2) {
1269 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270 j->cadence_f[5].state = 3;
1271 } else {
1272 j->cadence_f[5].state = 7;
1273 }
1274 }
1275 break;
1276 case 3:
1277 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278 if(ixjdebug & 0x0004) {
1279 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280 }
1281 ixj_ring_off(j);
1282 if (j->cadence_f[5].off2) {
1283 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284 j->cadence_f[5].state = 4;
1285 } else {
1286 j->cadence_f[5].state = 7;
1287 }
1288 }
1289 break;
1290 case 4:
1291 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292 if(ixjdebug & 0x0004) {
1293 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294 }
1295 ixj_ring_on(j);
1296 if (j->cadence_f[5].on3) {
1297 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298 j->cadence_f[5].state = 5;
1299 } else {
1300 j->cadence_f[5].state = 7;
1301 }
1302 }
1303 break;
1304 case 5:
1305 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306 if(ixjdebug & 0x0004) {
1307 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308 }
1309 ixj_ring_off(j);
1310 if (j->cadence_f[5].off3) {
1311 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312 j->cadence_f[5].state = 6;
1313 } else {
1314 j->cadence_f[5].state = 7;
1315 }
1316 }
1317 break;
1318 case 6:
1319 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320 if(ixjdebug & 0x0004) {
1321 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322 }
1323 j->cadence_f[5].state = 7;
1324 }
1325 break;
1326 case 7:
1327 if(ixjdebug & 0x0004) {
1328 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329 }
1330 j->flags.cidring = 1;
1331 j->cadence_f[5].state = 0;
1332 break;
1333 }
1334 if (j->flags.cidring && !j->flags.cidsent) {
1335 j->flags.cidsent = 1;
1336 if(j->fskdcnt) {
1337 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338 ixj_pre_cid(j);
1339 }
1340 j->flags.cidring = 0;
1341 }
1342 clear_bit(board, &j->busyflags);
1343 ixj_add_timer(j);
1344 return;
1345 } else {
1346 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347 if (j->flags.cidring && !j->flags.cidsent) {
1348 j->flags.cidsent = 1;
1349 if(j->fskdcnt) {
1350 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351 ixj_pre_cid(j);
1352 }
1353 j->flags.cidring = 0;
1354 }
1355 j->ring_cadence_t--;
1356 if (j->ring_cadence_t == -1)
1357 j->ring_cadence_t = 15;
1358 j->ring_cadence_jif = jiffies;
1359
1360 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362 j->flags.firstring = 1;
1363 else
1364 ixj_ring_on(j);
1365 } else {
1366 ixj_ring_off(j);
1367 if(!j->flags.cidsent)
1368 j->flags.cidring = 1;
1369 }
1370 }
1371 clear_bit(board, &j->busyflags);
1372 ixj_add_timer(j);
1373 return;
1374 }
1375 }
1376 if (!j->flags.ringing) {
1377 if (j->hookstate) { /* & 1) { */
1378 if (j->dsp.low != 0x20 &&
1379 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381 }
1382 LineMonitor(j);
1383 read_filters(j);
1384 ixj_WriteDSPCommand(0x511B, j);
1385 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386 if (!j->m_hook && (j->hookstate & 1)) {
1387 j->m_hook = j->ex.bits.hookstate = 1;
1388 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389 }
1390 } else {
1391 if (j->ex.bits.dtmf_ready) {
1392 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393 }
1394 if (j->m_hook) {
1395 j->m_hook = 0;
1396 j->ex.bits.hookstate = 1;
1397 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398 }
1399 }
1400 }
1401 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402 ixj_pstn_state(j);
1403 }
1404 if (j->ex.bytes) {
1405 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1406 }
1407 clear_bit(board, &j->busyflags);
1408 }
1409 ixj_add_timer(j);
1410 }
1411
1412 static int ixj_status_wait(IXJ *j)
1413 {
1414 unsigned long jif;
1415
1416 jif = jiffies + ((60 * hertz) / 100);
1417 while (!IsStatusReady(j)) {
1418 ixj_perfmon(j->statuswait);
1419 if (time_after(jiffies, jif)) {
1420 ixj_perfmon(j->statuswaitfail);
1421 return -1;
1422 }
1423 }
1424 return 0;
1425 }
1426
1427 static int ixj_PCcontrol_wait(IXJ *j)
1428 {
1429 unsigned long jif;
1430
1431 jif = jiffies + ((60 * hertz) / 100);
1432 while (!IsPCControlReady(j)) {
1433 ixj_perfmon(j->pcontrolwait);
1434 if (time_after(jiffies, jif)) {
1435 ixj_perfmon(j->pcontrolwaitfail);
1436 return -1;
1437 }
1438 }
1439 return 0;
1440 }
1441
1442 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443 {
1444 BYTES bytes;
1445 unsigned long jif;
1446
1447 atomic_inc(&j->DSPWrite);
1448 if(atomic_read(&j->DSPWrite) > 1) {
1449 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450 return -1;
1451 }
1452 bytes.high = (cmd & 0xFF00) >> 8;
1453 bytes.low = cmd & 0x00FF;
1454 jif = jiffies + ((60 * hertz) / 100);
1455 while (!IsControlReady(j)) {
1456 ixj_perfmon(j->iscontrolready);
1457 if (time_after(jiffies, jif)) {
1458 ixj_perfmon(j->iscontrolreadyfail);
1459 atomic_dec(&j->DSPWrite);
1460 if(atomic_read(&j->DSPWrite) > 0) {
1461 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462 while(atomic_read(&j->DSPWrite) > 0) {
1463 atomic_dec(&j->DSPWrite);
1464 }
1465 }
1466 return -1;
1467 }
1468 }
1469 outb(bytes.low, j->DSPbase + 6);
1470 outb(bytes.high, j->DSPbase + 7);
1471
1472 if (ixj_status_wait(j)) {
1473 j->ssr.low = 0xFF;
1474 j->ssr.high = 0xFF;
1475 atomic_dec(&j->DSPWrite);
1476 if(atomic_read(&j->DSPWrite) > 0) {
1477 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478 while(atomic_read(&j->DSPWrite) > 0) {
1479 atomic_dec(&j->DSPWrite);
1480 }
1481 }
1482 return -1;
1483 }
1484 /* Read Software Status Register */
1485 j->ssr.low = inb_p(j->DSPbase + 2);
1486 j->ssr.high = inb_p(j->DSPbase + 3);
1487 atomic_dec(&j->DSPWrite);
1488 if(atomic_read(&j->DSPWrite) > 0) {
1489 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490 while(atomic_read(&j->DSPWrite) > 0) {
1491 atomic_dec(&j->DSPWrite);
1492 }
1493 }
1494 return 0;
1495 }
1496
1497 /***************************************************************************
1498 *
1499 * General Purpose IO Register read routine
1500 *
1501 ***************************************************************************/
1502 static inline int ixj_gpio_read(IXJ *j)
1503 {
1504 if (ixj_WriteDSPCommand(0x5143, j))
1505 return -1;
1506
1507 j->gpio.bytes.low = j->ssr.low;
1508 j->gpio.bytes.high = j->ssr.high;
1509
1510 return 0;
1511 }
1512
1513 static inline void LED_SetState(int state, IXJ *j)
1514 {
1515 if (j->cardtype == QTI_LINEJACK) {
1516 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521 outb(j->pld_scrw.byte, j->XILINXbase);
1522 }
1523 }
1524
1525 /*********************************************************************
1526 * GPIO Pins are configured as follows on the Quicknet Internet
1527 * PhoneJACK Telephony Cards
1528 *
1529 * POTS Select GPIO_6=0 GPIO_7=0
1530 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531 * Handset Select GPIO_6=1 GPIO_7=0
1532 *
1533 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1534 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1535 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1536 *
1537 * Hook Switch changes reported on GPIO_3
1538 *********************************************************************/
1539 static int ixj_set_port(IXJ *j, int arg)
1540 {
1541 if (j->cardtype == QTI_PHONEJACK_LITE) {
1542 if (arg != PORT_POTS)
1543 return 10;
1544 else
1545 return 0;
1546 }
1547 switch (arg) {
1548 case PORT_POTS:
1549 j->port = PORT_POTS;
1550 switch (j->cardtype) {
1551 case QTI_PHONECARD:
1552 if (j->flags.pcmciasct == 1)
1553 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554 else
1555 return 11;
1556 break;
1557 case QTI_PHONEJACK_PCI:
1558 j->pld_slicw.pcib.mic = 0;
1559 j->pld_slicw.pcib.spk = 0;
1560 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561 break;
1562 case QTI_LINEJACK:
1563 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1564 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1565 Software Control Register */
1566 return 2;
1567 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1568
1569 outb(j->pld_scrw.byte, j->XILINXbase);
1570 j->pld_clock.byte = 0;
1571 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572 j->pld_slicw.bits.rly1 = 1;
1573 j->pld_slicw.bits.spken = 0;
1574 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1576 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1577 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1578 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1579 ixj_mixer(0x0E80, j); /*Mic mute */
1580 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1581 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1582 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1583 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585 break;
1586 case QTI_PHONEJACK:
1587 j->gpio.bytes.high = 0x0B;
1588 j->gpio.bits.gpio6 = 0;
1589 j->gpio.bits.gpio7 = 0;
1590 ixj_WriteDSPCommand(j->gpio.word, j);
1591 break;
1592 }
1593 break;
1594 case PORT_PSTN:
1595 if (j->cardtype == QTI_LINEJACK) {
1596 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598 j->pld_slicw.bits.rly3 = 0;
1599 j->pld_slicw.bits.rly1 = 1;
1600 j->pld_slicw.bits.spken = 0;
1601 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602 j->port = PORT_PSTN;
1603 } else {
1604 return 4;
1605 }
1606 break;
1607 case PORT_SPEAKER:
1608 j->port = PORT_SPEAKER;
1609 switch (j->cardtype) {
1610 case QTI_PHONECARD:
1611 if (j->flags.pcmciasct) {
1612 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613 }
1614 break;
1615 case QTI_PHONEJACK_PCI:
1616 j->pld_slicw.pcib.mic = 1;
1617 j->pld_slicw.pcib.spk = 1;
1618 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619 break;
1620 case QTI_LINEJACK:
1621 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1622 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1623 Software Control Register */
1624 return 2;
1625 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1626
1627 outb(j->pld_scrw.byte, j->XILINXbase);
1628 j->pld_clock.byte = 0;
1629 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630 j->pld_slicw.bits.rly1 = 1;
1631 j->pld_slicw.bits.spken = 1;
1632 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1634 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1635 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1636 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1637 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1638 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1639 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1640 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1641 break;
1642 case QTI_PHONEJACK:
1643 j->gpio.bytes.high = 0x0B;
1644 j->gpio.bits.gpio6 = 0;
1645 j->gpio.bits.gpio7 = 1;
1646 ixj_WriteDSPCommand(j->gpio.word, j);
1647 break;
1648 }
1649 break;
1650 case PORT_HANDSET:
1651 if (j->cardtype != QTI_PHONEJACK) {
1652 return 5;
1653 } else {
1654 j->gpio.bytes.high = 0x0B;
1655 j->gpio.bits.gpio6 = 1;
1656 j->gpio.bits.gpio7 = 0;
1657 ixj_WriteDSPCommand(j->gpio.word, j);
1658 j->port = PORT_HANDSET;
1659 }
1660 break;
1661 default:
1662 return 6;
1663 break;
1664 }
1665 return 0;
1666 }
1667
1668 static int ixj_set_pots(IXJ *j, int arg)
1669 {
1670 if (j->cardtype == QTI_LINEJACK) {
1671 if (arg) {
1672 if (j->port == PORT_PSTN) {
1673 j->pld_slicw.bits.rly1 = 0;
1674 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675 j->flags.pots_pstn = 1;
1676 return 1;
1677 } else {
1678 j->flags.pots_pstn = 0;
1679 return 0;
1680 }
1681 } else {
1682 j->pld_slicw.bits.rly1 = 1;
1683 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684 j->flags.pots_pstn = 0;
1685 return 1;
1686 }
1687 } else {
1688 return 0;
1689 }
1690 }
1691
1692 static void ixj_ring_on(IXJ *j)
1693 {
1694 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695 {
1696 if (ixjdebug & 0x0004)
1697 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1698
1699 j->gpio.bytes.high = 0x0B;
1700 j->gpio.bytes.low = 0x00;
1701 j->gpio.bits.gpio1 = 1;
1702 j->gpio.bits.gpio2 = 1;
1703 j->gpio.bits.gpio5 = 0;
1704 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1705 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706 {
1707 if (ixjdebug & 0x0004)
1708 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711 }
1712 }
1713
1714 static int ixj_siadc(IXJ *j, int val)
1715 {
1716 if(j->cardtype == QTI_PHONECARD){
1717 if(j->flags.pcmciascp){
1718 if(val == -1)
1719 return j->siadc.bits.rxg;
1720
1721 if(val < 0 || val > 0x1F)
1722 return -1;
1723
1724 j->siadc.bits.hom = 0; /* Handset Out Mute */
1725 j->siadc.bits.lom = 0; /* Line Out Mute */
1726 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1727 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1728 j->psccr.bits.rw = 0; /* Read / Write flag */
1729 j->psccr.bits.dev = 0;
1730 outb(j->siadc.byte, j->XILINXbase + 0x00);
1731 outb(j->psccr.byte, j->XILINXbase + 0x01);
1732 ixj_PCcontrol_wait(j);
1733 return j->siadc.bits.rxg;
1734 }
1735 }
1736 return -1;
1737 }
1738
1739 static int ixj_sidac(IXJ *j, int val)
1740 {
1741 if(j->cardtype == QTI_PHONECARD){
1742 if(j->flags.pcmciascp){
1743 if(val == -1)
1744 return j->sidac.bits.txg;
1745
1746 if(val < 0 || val > 0x1F)
1747 return -1;
1748
1749 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1750 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1751 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1752 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1753 j->psccr.bits.rw = 0; /* Read / Write flag */
1754 j->psccr.bits.dev = 0;
1755 outb(j->sidac.byte, j->XILINXbase + 0x00);
1756 outb(j->psccr.byte, j->XILINXbase + 0x01);
1757 ixj_PCcontrol_wait(j);
1758 return j->sidac.bits.txg;
1759 }
1760 }
1761 return -1;
1762 }
1763
1764 static int ixj_pcmcia_cable_check(IXJ *j)
1765 {
1766 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767 if (!j->flags.pcmciastate) {
1768 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770 j->flags.pcmciastate = 4;
1771 return 0;
1772 }
1773 if (j->pccr1.bits.ed) {
1774 j->pccr1.bits.ed = 0;
1775 j->psccr.bits.dev = 3;
1776 j->psccr.bits.rw = 1;
1777 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778 ixj_PCcontrol_wait(j);
1779 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781 j->psccr.bits.dev = 3;
1782 j->psccr.bits.rw = 0;
1783 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784 ixj_PCcontrol_wait(j);
1785 return j->pslic.bits.led2 ? 1 : 0;
1786 } else if (j->flags.pcmciasct) {
1787 return j->r_hook;
1788 } else {
1789 return 1;
1790 }
1791 } else if (j->flags.pcmciastate == 4) {
1792 if (!j->pccr1.bits.drf) {
1793 j->flags.pcmciastate = 3;
1794 }
1795 return 0;
1796 } else if (j->flags.pcmciastate == 3) {
1797 j->pccr2.bits.pwr = 0;
1798 j->pccr2.bits.rstc = 1;
1799 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800 j->checkwait = jiffies + (hertz * 2);
1801 j->flags.incheck = 1;
1802 j->flags.pcmciastate = 2;
1803 return 0;
1804 } else if (j->flags.pcmciastate == 2) {
1805 if (j->flags.incheck) {
1806 if (time_before(jiffies, j->checkwait)) {
1807 return 0;
1808 } else {
1809 j->flags.incheck = 0;
1810 }
1811 }
1812 j->pccr2.bits.pwr = 0;
1813 j->pccr2.bits.rstc = 0;
1814 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815 j->flags.pcmciastate = 1;
1816 return 0;
1817 } else if (j->flags.pcmciastate == 1) {
1818 j->flags.pcmciastate = 0;
1819 if (!j->pccr1.bits.drf) {
1820 j->psccr.bits.dev = 3;
1821 j->psccr.bits.rw = 1;
1822 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823 ixj_PCcontrol_wait(j);
1824 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1825
1826 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1827
1828 if (j->flags.pcmciasct == 3) {
1829 j->flags.pcmciastate = 4;
1830 return 0;
1831 } else if (j->flags.pcmciasct == 0) {
1832 j->pccr2.bits.pwr = 1;
1833 j->pccr2.bits.rstc = 0;
1834 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835 j->port = PORT_SPEAKER;
1836 } else {
1837 j->port = PORT_POTS;
1838 }
1839 j->sic1.bits.cpd = 0; /* Chip Power Down */
1840 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1841 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1842 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1843 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1844 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1845 j->psccr.bits.rw = 0; /* Read / Write flag */
1846 j->psccr.bits.dev = 0;
1847 outb(j->sic1.byte, j->XILINXbase + 0x00);
1848 outb(j->psccr.byte, j->XILINXbase + 0x01);
1849 ixj_PCcontrol_wait(j);
1850
1851 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1852 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1853 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1854 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1855 j->sic2.bits.hpd = 0; /* HPF disable */
1856 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1857 j->psccr.bits.rw = 0; /* Read / Write flag */
1858 j->psccr.bits.dev = 0;
1859 outb(j->sic2.byte, j->XILINXbase + 0x00);
1860 outb(j->psccr.byte, j->XILINXbase + 0x01);
1861 ixj_PCcontrol_wait(j);
1862
1863 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1864 j->psccr.bits.rw = 0; /* Read / Write flag */
1865 j->psccr.bits.dev = 0;
1866 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1867 outb(j->psccr.byte, j->XILINXbase + 0x01);
1868 ixj_PCcontrol_wait(j);
1869
1870 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1871 j->psccr.bits.rw = 0; /* Read / Write flag */
1872 j->psccr.bits.dev = 0;
1873 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1874 outb(j->psccr.byte, j->XILINXbase + 0x01);
1875 ixj_PCcontrol_wait(j);
1876
1877 j->sirxg.bits.lig = 1; /* Line In Gain */
1878 j->sirxg.bits.lim = 1; /* Line In Mute */
1879 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1880 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1881 j->sirxg.bits.him = 0; /* Handset In Mute */
1882 j->sirxg.bits.iir = 1; /* IIR */
1883 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1884 j->psccr.bits.rw = 0; /* Read / Write flag */
1885 j->psccr.bits.dev = 0;
1886 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887 outb(j->psccr.byte, j->XILINXbase + 0x01);
1888 ixj_PCcontrol_wait(j);
1889
1890 ixj_siadc(j, 0x17);
1891 ixj_sidac(j, 0x1D);
1892
1893 j->siaatt.bits.sot = 0;
1894 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1895 j->psccr.bits.rw = 0; /* Read / Write flag */
1896 j->psccr.bits.dev = 0;
1897 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898 outb(j->psccr.byte, j->XILINXbase + 0x01);
1899 ixj_PCcontrol_wait(j);
1900
1901 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902 j->psccr.byte = j->pslic.byte = 0;
1903 j->pslic.bits.powerdown = 1;
1904 j->psccr.bits.dev = 3;
1905 j->psccr.bits.rw = 0;
1906 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907 ixj_PCcontrol_wait(j);
1908 }
1909 }
1910 return 0;
1911 } else {
1912 j->flags.pcmciascp = 0;
1913 return 0;
1914 }
1915 return 0;
1916 }
1917
1918 static int ixj_hookstate(IXJ *j)
1919 {
1920 int fOffHook = 0;
1921
1922 switch (j->cardtype) {
1923 case QTI_PHONEJACK:
1924 ixj_gpio_read(j);
1925 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1926 break;
1927 case QTI_LINEJACK:
1928 case QTI_PHONEJACK_LITE:
1929 case QTI_PHONEJACK_PCI:
1930 SLIC_GetState(j);
1931 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1932 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1933 if(fOffHook != j->p_hook) {
1934 if(!j->checkwait) {
1935 j->checkwait = jiffies;
1936 }
1937 if(time_before(jiffies, j->checkwait + 2)) {
1938 fOffHook ^= 1;
1939 } else {
1940 j->checkwait = 0;
1941 }
1942 j->p_hook = fOffHook;
1943 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1944 }
1945 } else {
1946 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1947 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1948 if (j->flags.ringing || j->flags.cringing) {
1949 if (!in_interrupt()) {
1950 msleep(20);
1951 }
1952 SLIC_GetState(j);
1953 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1954 ixj_ring_on(j);
1955 }
1956 }
1957 if (j->cardtype == QTI_PHONEJACK_PCI) {
1958 j->pld_scrr.byte = inb_p(j->XILINXbase);
1959 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1960 } else
1961 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1962 }
1963 }
1964 break;
1965 case QTI_PHONECARD:
1966 fOffHook = ixj_pcmcia_cable_check(j);
1967 break;
1968 }
1969 if (j->r_hook != fOffHook) {
1970 j->r_hook = fOffHook;
1971 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1972 j->ex.bits.hookstate = 1;
1973 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1974 } else if (!fOffHook) {
1975 j->flash_end = jiffies + ((60 * hertz) / 100);
1976 }
1977 }
1978 if (fOffHook) {
1979 if(time_before(jiffies, j->flash_end)) {
1980 j->ex.bits.flash = 1;
1981 j->flash_end = 0;
1982 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1983 }
1984 } else {
1985 if(time_before(jiffies, j->flash_end)) {
1986 fOffHook = 1;
1987 }
1988 }
1989
1990 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1991 fOffHook |= 2;
1992
1993 if (j->port == PORT_SPEAKER) {
1994 if(j->cardtype == QTI_PHONECARD) {
1995 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1996 fOffHook |= 2;
1997 }
1998 } else {
1999 fOffHook |= 2;
2000 }
2001 }
2002
2003 if (j->port == PORT_HANDSET)
2004 fOffHook |= 2;
2005
2006 return fOffHook;
2007 }
2008
2009 static void ixj_ring_off(IXJ *j)
2010 {
2011 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2012 {
2013 if (ixjdebug & 0x0004)
2014 printk(KERN_INFO "IXJ Ring Off\n");
2015 j->gpio.bytes.high = 0x0B;
2016 j->gpio.bytes.low = 0x00;
2017 j->gpio.bits.gpio1 = 0;
2018 j->gpio.bits.gpio2 = 1;
2019 j->gpio.bits.gpio5 = 0;
2020 ixj_WriteDSPCommand(j->gpio.word, j);
2021 } else /* Internet LineJACK */
2022 {
2023 if (ixjdebug & 0x0004)
2024 printk(KERN_INFO "IXJ Ring Off\n");
2025
2026 if(!j->flags.cidplay)
2027 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2028
2029 SLIC_GetState(j);
2030 }
2031 }
2032
2033 static void ixj_ring_start(IXJ *j)
2034 {
2035 j->flags.cringing = 1;
2036 if (ixjdebug & 0x0004)
2037 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2038 if (ixj_hookstate(j) & 1) {
2039 if (j->port == PORT_POTS)
2040 ixj_ring_off(j);
2041 j->flags.cringing = 0;
2042 if (ixjdebug & 0x0004)
2043 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2044 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2045 j->ring_cadence_jif = jiffies;
2046 j->flags.cidsent = j->flags.cidring = 0;
2047 j->cadence_f[5].state = 0;
2048 if(j->cadence_f[5].on1)
2049 ixj_ring_on(j);
2050 } else {
2051 j->ring_cadence_jif = jiffies;
2052 j->ring_cadence_t = 15;
2053 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2054 ixj_ring_on(j);
2055 } else {
2056 ixj_ring_off(j);
2057 }
2058 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2059 }
2060 }
2061
2062 static int ixj_ring(IXJ *j)
2063 {
2064 char cntr;
2065 unsigned long jif;
2066
2067 j->flags.ringing = 1;
2068 if (ixj_hookstate(j) & 1) {
2069 ixj_ring_off(j);
2070 j->flags.ringing = 0;
2071 return 1;
2072 }
2073 for (cntr = 0; cntr < j->maxrings; cntr++) {
2074 jif = jiffies + (1 * hertz);
2075 ixj_ring_on(j);
2076 while (time_before(jiffies, jif)) {
2077 if (ixj_hookstate(j) & 1) {
2078 ixj_ring_off(j);
2079 j->flags.ringing = 0;
2080 return 1;
2081 }
2082 schedule_timeout_interruptible(1);
2083 if (signal_pending(current))
2084 break;
2085 }
2086 jif = jiffies + (3 * hertz);
2087 ixj_ring_off(j);
2088 while (time_before(jiffies, jif)) {
2089 if (ixj_hookstate(j) & 1) {
2090 msleep(10);
2091 if (ixj_hookstate(j) & 1) {
2092 j->flags.ringing = 0;
2093 return 1;
2094 }
2095 }
2096 schedule_timeout_interruptible(1);
2097 if (signal_pending(current))
2098 break;
2099 }
2100 }
2101 ixj_ring_off(j);
2102 j->flags.ringing = 0;
2103 return 0;
2104 }
2105
2106 static int ixj_open(struct phone_device *p, struct file *file_p)
2107 {
2108 IXJ *j = get_ixj(p->board);
2109 file_p->private_data = j;
2110
2111 if (!j->DSPbase)
2112 return -ENODEV;
2113
2114 if (file_p->f_mode & FMODE_READ) {
2115 if(!j->readers) {
2116 j->readers++;
2117 } else {
2118 return -EBUSY;
2119 }
2120 }
2121
2122 if (file_p->f_mode & FMODE_WRITE) {
2123 if(!j->writers) {
2124 j->writers++;
2125 } else {
2126 if (file_p->f_mode & FMODE_READ){
2127 j->readers--;
2128 }
2129 return -EBUSY;
2130 }
2131 }
2132
2133 if (j->cardtype == QTI_PHONECARD) {
2134 j->pslic.bits.powerdown = 0;
2135 j->psccr.bits.dev = 3;
2136 j->psccr.bits.rw = 0;
2137 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2138 ixj_PCcontrol_wait(j);
2139 }
2140
2141 j->flags.cidplay = 0;
2142 j->flags.cidcw_ack = 0;
2143
2144 if (ixjdebug & 0x0002)
2145 printk(KERN_INFO "Opening board %d\n", p->board);
2146
2147 j->framesread = j->frameswritten = 0;
2148 return 0;
2149 }
2150
2151 static int ixj_release(struct inode *inode, struct file *file_p)
2152 {
2153 IXJ_TONE ti;
2154 int cnt;
2155 IXJ *j = file_p->private_data;
2156 int board = j->p.board;
2157
2158 /*
2159 * Set up locks to ensure that only one process is talking to the DSP at a time.
2160 * This is necessary to keep the DSP from locking up.
2161 */
2162 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2163 schedule_timeout_interruptible(1);
2164 if (ixjdebug & 0x0002)
2165 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2166
2167 if (j->cardtype == QTI_PHONECARD)
2168 ixj_set_port(j, PORT_SPEAKER);
2169 else
2170 ixj_set_port(j, PORT_POTS);
2171
2172 aec_stop(j);
2173 ixj_play_stop(j);
2174 ixj_record_stop(j);
2175 set_play_volume(j, 0x100);
2176 set_rec_volume(j, 0x100);
2177 ixj_ring_off(j);
2178
2179 /* Restore the tone table to default settings. */
2180 ti.tone_index = 10;
2181 ti.gain0 = 1;
2182 ti.freq0 = hz941;
2183 ti.gain1 = 0;
2184 ti.freq1 = hz1209;
2185 ixj_init_tone(j, &ti);
2186 ti.tone_index = 11;
2187 ti.gain0 = 1;
2188 ti.freq0 = hz941;
2189 ti.gain1 = 0;
2190 ti.freq1 = hz1336;
2191 ixj_init_tone(j, &ti);
2192 ti.tone_index = 12;
2193 ti.gain0 = 1;
2194 ti.freq0 = hz941;
2195 ti.gain1 = 0;
2196 ti.freq1 = hz1477;
2197 ixj_init_tone(j, &ti);
2198 ti.tone_index = 13;
2199 ti.gain0 = 1;
2200 ti.freq0 = hz800;
2201 ti.gain1 = 0;
2202 ti.freq1 = 0;
2203 ixj_init_tone(j, &ti);
2204 ti.tone_index = 14;
2205 ti.gain0 = 1;
2206 ti.freq0 = hz1000;
2207 ti.gain1 = 0;
2208 ti.freq1 = 0;
2209 ixj_init_tone(j, &ti);
2210 ti.tone_index = 15;
2211 ti.gain0 = 1;
2212 ti.freq0 = hz1250;
2213 ti.gain1 = 0;
2214 ti.freq1 = 0;
2215 ixj_init_tone(j, &ti);
2216 ti.tone_index = 16;
2217 ti.gain0 = 1;
2218 ti.freq0 = hz950;
2219 ti.gain1 = 0;
2220 ti.freq1 = 0;
2221 ixj_init_tone(j, &ti);
2222 ti.tone_index = 17;
2223 ti.gain0 = 1;
2224 ti.freq0 = hz1100;
2225 ti.gain1 = 0;
2226 ti.freq1 = 0;
2227 ixj_init_tone(j, &ti);
2228 ti.tone_index = 18;
2229 ti.gain0 = 1;
2230 ti.freq0 = hz1400;
2231 ti.gain1 = 0;
2232 ti.freq1 = 0;
2233 ixj_init_tone(j, &ti);
2234 ti.tone_index = 19;
2235 ti.gain0 = 1;
2236 ti.freq0 = hz1500;
2237 ti.gain1 = 0;
2238 ti.freq1 = 0;
2239 ixj_init_tone(j, &ti);
2240 ti.tone_index = 20;
2241 ti.gain0 = 1;
2242 ti.freq0 = hz1600;
2243 ti.gain1 = 0;
2244 ti.freq1 = 0;
2245 ixj_init_tone(j, &ti);
2246 ti.tone_index = 21;
2247 ti.gain0 = 1;
2248 ti.freq0 = hz1800;
2249 ti.gain1 = 0;
2250 ti.freq1 = 0;
2251 ixj_init_tone(j, &ti);
2252 ti.tone_index = 22;
2253 ti.gain0 = 1;
2254 ti.freq0 = hz2100;
2255 ti.gain1 = 0;
2256 ti.freq1 = 0;
2257 ixj_init_tone(j, &ti);
2258 ti.tone_index = 23;
2259 ti.gain0 = 1;
2260 ti.freq0 = hz1300;
2261 ti.gain1 = 0;
2262 ti.freq1 = 0;
2263 ixj_init_tone(j, &ti);
2264 ti.tone_index = 24;
2265 ti.gain0 = 1;
2266 ti.freq0 = hz2450;
2267 ti.gain1 = 0;
2268 ti.freq1 = 0;
2269 ixj_init_tone(j, &ti);
2270 ti.tone_index = 25;
2271 ti.gain0 = 1;
2272 ti.freq0 = hz350;
2273 ti.gain1 = 0;
2274 ti.freq1 = hz440;
2275 ixj_init_tone(j, &ti);
2276 ti.tone_index = 26;
2277 ti.gain0 = 1;
2278 ti.freq0 = hz440;
2279 ti.gain1 = 0;
2280 ti.freq1 = hz480;
2281 ixj_init_tone(j, &ti);
2282 ti.tone_index = 27;
2283 ti.gain0 = 1;
2284 ti.freq0 = hz480;
2285 ti.gain1 = 0;
2286 ti.freq1 = hz620;
2287 ixj_init_tone(j, &ti);
2288
2289 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2290
2291 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2292
2293 j->ex.bits.dtmf_ready = 0;
2294 j->dtmf_state = 0;
2295 j->dtmf_wp = j->dtmf_rp = 0;
2296 j->rec_mode = j->play_mode = -1;
2297 j->flags.ringing = 0;
2298 j->maxrings = MAXRINGS;
2299 j->ring_cadence = USA_RING_CADENCE;
2300 if(j->cadence_f[5].enable) {
2301 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2302 }
2303 j->drybuffer = 0;
2304 j->winktime = 320;
2305 j->flags.dtmf_oob = 0;
2306 for (cnt = 0; cnt < 4; cnt++)
2307 j->cadence_f[cnt].enable = 0;
2308
2309 idle(j);
2310
2311 if(j->cardtype == QTI_PHONECARD) {
2312 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2313 }
2314
2315 if (file_p->f_mode & FMODE_READ)
2316 j->readers--;
2317 if (file_p->f_mode & FMODE_WRITE)
2318 j->writers--;
2319
2320 if (j->read_buffer && !j->readers) {
2321 kfree(j->read_buffer);
2322 j->read_buffer = NULL;
2323 j->read_buffer_size = 0;
2324 }
2325 if (j->write_buffer && !j->writers) {
2326 kfree(j->write_buffer);
2327 j->write_buffer = NULL;
2328 j->write_buffer_size = 0;
2329 }
2330 j->rec_codec = j->play_codec = 0;
2331 j->rec_frame_size = j->play_frame_size = 0;
2332 j->flags.cidsent = j->flags.cidring = 0;
2333 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2334
2335 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2336 ixj_set_port(j, PORT_PSTN);
2337 daa_set_mode(j, SOP_PU_SLEEP);
2338 ixj_set_pots(j, 1);
2339 }
2340 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2341
2342 /* Set up the default signals for events */
2343 for (cnt = 0; cnt < 35; cnt++)
2344 j->ixj_signals[cnt] = SIGIO;
2345
2346 /* Set the excetion signal enable flags */
2347 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2348 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 =
2349 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;
2350
2351 file_p->private_data = NULL;
2352 clear_bit(board, &j->busyflags);
2353 return 0;
2354 }
2355
2356 static int read_filters(IXJ *j)
2357 {
2358 unsigned short fc, cnt, trg;
2359 int var;
2360
2361 trg = 0;
2362 if (ixj_WriteDSPCommand(0x5144, j)) {
2363 if(ixjdebug & 0x0001) {
2364 printk(KERN_INFO "Read Frame Counter failed!\n");
2365 }
2366 return -1;
2367 }
2368 fc = j->ssr.high << 8 | j->ssr.low;
2369 if (fc == j->frame_count)
2370 return 1;
2371
2372 j->frame_count = fc;
2373
2374 if (j->dtmf_proc)
2375 return 1;
2376
2377 var = 10;
2378
2379 for (cnt = 0; cnt < 4; cnt++) {
2380 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2381 if(ixjdebug & 0x0001) {
2382 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2383 }
2384 return -1;
2385 }
2386 if (ixj_WriteDSPCommand(0x515C, j)) {
2387 if(ixjdebug & 0x0001) {
2388 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2389 }
2390 return -1;
2391 }
2392 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2393
2394 if (j->cadence_f[cnt].enable) {
2395 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2396 if (j->cadence_f[cnt].state == 0) {
2397 j->cadence_f[cnt].state = 1;
2398 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2399 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2400 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2401 } else if (j->cadence_f[cnt].state == 2 &&
2402 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2403 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2404 if (j->cadence_f[cnt].on2) {
2405 j->cadence_f[cnt].state = 3;
2406 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2407 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2408 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2409 } else {
2410 j->cadence_f[cnt].state = 7;
2411 }
2412 } else if (j->cadence_f[cnt].state == 4 &&
2413 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2414 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2415 if (j->cadence_f[cnt].on3) {
2416 j->cadence_f[cnt].state = 5;
2417 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2418 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2419 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2420 } else {
2421 j->cadence_f[cnt].state = 7;
2422 }
2423 } else {
2424 j->cadence_f[cnt].state = 0;
2425 }
2426 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2427 if (j->cadence_f[cnt].state == 1) {
2428 if(!j->cadence_f[cnt].on1) {
2429 j->cadence_f[cnt].state = 7;
2430 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2431 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2432 if(j->cadence_f[cnt].off1) {
2433 j->cadence_f[cnt].state = 2;
2434 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2435 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2436 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2437 } else {
2438 j->cadence_f[cnt].state = 7;
2439 }
2440 } else {
2441 j->cadence_f[cnt].state = 0;
2442 }
2443 } else if (j->cadence_f[cnt].state == 3) {
2444 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2445 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2446 if(j->cadence_f[cnt].off2) {
2447 j->cadence_f[cnt].state = 4;
2448 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2449 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2450 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2451 } else {
2452 j->cadence_f[cnt].state = 7;
2453 }
2454 } else {
2455 j->cadence_f[cnt].state = 0;
2456 }
2457 } else if (j->cadence_f[cnt].state == 5) {
2458 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2459 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2460 if(j->cadence_f[cnt].off3) {
2461 j->cadence_f[cnt].state = 6;
2462 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2463 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2464 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2465 } else {
2466 j->cadence_f[cnt].state = 7;
2467 }
2468 } else {
2469 j->cadence_f[cnt].state = 0;
2470 }
2471 } else {
2472 j->cadence_f[cnt].state = 0;
2473 }
2474 } else {
2475 switch(j->cadence_f[cnt].state) {
2476 case 1:
2477 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2478 !j->cadence_f[cnt].off1 &&
2479 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2480 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2481 j->cadence_f[cnt].state = 7;
2482 }
2483 break;
2484 case 3:
2485 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2486 !j->cadence_f[cnt].off2 &&
2487 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2488 j->cadence_f[cnt].state = 7;
2489 }
2490 break;
2491 case 5:
2492 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2493 !j->cadence_f[cnt].off3) {
2494 j->cadence_f[cnt].state = 7;
2495 }
2496 break;
2497 }
2498 }
2499
2500 if (ixjdebug & 0x0040) {
2501 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2502 switch(j->cadence_f[cnt].state) {
2503 case 0:
2504 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2505 break;
2506 case 1:
2507 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2508 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2509 break;
2510 case 2:
2511 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2512 j->cadence_f[cnt].off1max);
2513 break;
2514 case 3:
2515 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2516 j->cadence_f[cnt].on2max);
2517 break;
2518 case 4:
2519 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2520 j->cadence_f[cnt].off2max);
2521 break;
2522 case 5:
2523 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2524 j->cadence_f[cnt].on3max);
2525 break;
2526 case 6:
2527 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2528 j->cadence_f[cnt].off3max);
2529 break;
2530 }
2531 }
2532 }
2533 if (j->cadence_f[cnt].state == 7) {
2534 j->cadence_f[cnt].state = 0;
2535 if (j->cadence_f[cnt].enable == 1)
2536 j->cadence_f[cnt].enable = 0;
2537 switch (cnt) {
2538 case 0:
2539 if(ixjdebug & 0x0020) {
2540 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2541 }
2542 j->ex.bits.fc0 = 1;
2543 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2544 break;
2545 case 1:
2546 if(ixjdebug & 0x0020) {
2547 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2548 }
2549 j->ex.bits.fc1 = 1;
2550 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2551 break;
2552 case 2:
2553 if(ixjdebug & 0x0020) {
2554 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2555 }
2556 j->ex.bits.fc2 = 1;
2557 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2558 break;
2559 case 3:
2560 if(ixjdebug & 0x0020) {
2561 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2562 }
2563 j->ex.bits.fc3 = 1;
2564 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2565 break;
2566 }
2567 }
2568 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2569 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2570 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2571 trg = 1;
2572 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2573 trg = 0;
2574 }
2575 switch (cnt) {
2576 case 0:
2577 if(ixjdebug & 0x0020) {
2578 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2579 }
2580 j->ex.bits.f0 = 1;
2581 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2582 break;
2583 case 1:
2584 if(ixjdebug & 0x0020) {
2585 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2586 }
2587 j->ex.bits.f1 = 1;
2588 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2589 break;
2590 case 2:
2591 if(ixjdebug & 0x0020) {
2592 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2593 }
2594 j->ex.bits.f2 = 1;
2595 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2596 break;
2597 case 3:
2598 if(ixjdebug & 0x0020) {
2599 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2600 }
2601 j->ex.bits.f3 = 1;
2602 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2603 break;
2604 }
2605 }
2606 }
2607 return 0;
2608 }
2609
2610 static int LineMonitor(IXJ *j)
2611 {
2612 if (j->dtmf_proc) {
2613 return -1;
2614 }
2615 j->dtmf_proc = 1;
2616
2617 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2618 return -1;
2619
2620 j->dtmf.bytes.high = j->ssr.high;
2621 j->dtmf.bytes.low = j->ssr.low;
2622 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2623 j->dtmf_state = 1;
2624 j->dtmf_current = j->dtmf.bits.digit;
2625 }
2626 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2627 {
2628 if(!j->cidcw_wait) {
2629 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2630 j->dtmf_wp++;
2631 if (j->dtmf_wp == 79)
2632 j->dtmf_wp = 0;
2633 j->ex.bits.dtmf_ready = 1;
2634 if(j->ex_sig.bits.dtmf_ready) {
2635 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2636 }
2637 }
2638 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2639 if(ixjdebug & 0x0020) {
2640 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2641 }
2642 j->flags.cidcw_ack = 1;
2643 }
2644 j->dtmf_state = 0;
2645 }
2646 j->dtmf_proc = 0;
2647
2648 return 0;
2649 }
2650
2651 /************************************************************************
2652 *
2653 * Functions to allow alaw <-> ulaw conversions.
2654 *
2655 ************************************************************************/
2656
2657 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2658 {
2659 static unsigned char table_ulaw2alaw[] =
2660 {
2661 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2662 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2663 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2664 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2665 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2666 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2667 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2668 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2669 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2670 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2671 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2672 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2673 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2674 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2675 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2676 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2677 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2678 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2679 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2680 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2681 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2682 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2683 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2684 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2685 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2686 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2687 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2688 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2689 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2690 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2691 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2692 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2693 };
2694
2695 while (len--)
2696 {
2697 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2698 buff++;
2699 }
2700 }
2701
2702 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2703 {
2704 static unsigned char table_alaw2ulaw[] =
2705 {
2706 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2707 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2708 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2709 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2710 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2711 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2712 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2713 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2714 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2715 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2716 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2717 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2718 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2719 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2720 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2721 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2722 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2723 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2724 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2725 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2726 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2727 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2728 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2729 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2730 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2731 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2732 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2733 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2734 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2735 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2736 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2737 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2738 };
2739
2740 while (len--)
2741 {
2742 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2743 buff++;
2744 }
2745 }
2746
2747 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2748 {
2749 unsigned long i = *ppos;
2750 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2751
2752 DECLARE_WAITQUEUE(wait, current);
2753
2754 if (j->flags.inread)
2755 return -EALREADY;
2756
2757 j->flags.inread = 1;
2758
2759 add_wait_queue(&j->read_q, &wait);
2760 set_current_state(TASK_INTERRUPTIBLE);
2761 mb();
2762
2763 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2764 ++j->read_wait;
2765 if (file_p->f_flags & O_NONBLOCK) {
2766 set_current_state(TASK_RUNNING);
2767 remove_wait_queue(&j->read_q, &wait);
2768 j->flags.inread = 0;
2769 return -EAGAIN;
2770 }
2771 if (!ixj_hookstate(j)) {
2772 set_current_state(TASK_RUNNING);
2773 remove_wait_queue(&j->read_q, &wait);
2774 j->flags.inread = 0;
2775 return 0;
2776 }
2777 interruptible_sleep_on(&j->read_q);
2778 if (signal_pending(current)) {
2779 set_current_state(TASK_RUNNING);
2780 remove_wait_queue(&j->read_q, &wait);
2781 j->flags.inread = 0;
2782 return -EINTR;
2783 }
2784 }
2785
2786 remove_wait_queue(&j->read_q, &wait);
2787 set_current_state(TASK_RUNNING);
2788 /* Don't ever copy more than the user asks */
2789 if(j->rec_codec == ALAW)
2790 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2791 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2792 j->read_buffer_ready = 0;
2793 if (i) {
2794 j->flags.inread = 0;
2795 return -EFAULT;
2796 } else {
2797 j->flags.inread = 0;
2798 return min(length, j->read_buffer_size);
2799 }
2800 }
2801
2802 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2803 loff_t * ppos)
2804 {
2805 int pre_retval;
2806 ssize_t read_retval = 0;
2807 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2808
2809 pre_retval = ixj_PreRead(j, 0L);
2810 switch (pre_retval) {
2811 case NORMAL:
2812 read_retval = ixj_read(file_p, buf, length, ppos);
2813 ixj_PostRead(j, 0L);
2814 break;
2815 case NOPOST:
2816 read_retval = ixj_read(file_p, buf, length, ppos);
2817 break;
2818 case POSTONLY:
2819 ixj_PostRead(j, 0L);
2820 break;
2821 default:
2822 read_retval = pre_retval;
2823 }
2824 return read_retval;
2825 }
2826
2827 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2828 {
2829 unsigned long i = *ppos;
2830 IXJ *j = file_p->private_data;
2831
2832 DECLARE_WAITQUEUE(wait, current);
2833
2834 if (j->flags.inwrite)
2835 return -EALREADY;
2836
2837 j->flags.inwrite = 1;
2838
2839 add_wait_queue(&j->write_q, &wait);
2840 set_current_state(TASK_INTERRUPTIBLE);
2841 mb();
2842
2843
2844 while (!j->write_buffers_empty) {
2845 ++j->write_wait;
2846 if (file_p->f_flags & O_NONBLOCK) {
2847 set_current_state(TASK_RUNNING);
2848 remove_wait_queue(&j->write_q, &wait);
2849 j->flags.inwrite = 0;
2850 return -EAGAIN;
2851 }
2852 if (!ixj_hookstate(j)) {
2853 set_current_state(TASK_RUNNING);
2854 remove_wait_queue(&j->write_q, &wait);
2855 j->flags.inwrite = 0;
2856 return 0;
2857 }
2858 interruptible_sleep_on(&j->write_q);
2859 if (signal_pending(current)) {
2860 set_current_state(TASK_RUNNING);
2861 remove_wait_queue(&j->write_q, &wait);
2862 j->flags.inwrite = 0;
2863 return -EINTR;
2864 }
2865 }
2866 set_current_state(TASK_RUNNING);
2867 remove_wait_queue(&j->write_q, &wait);
2868 if (j->write_buffer_wp + count >= j->write_buffer_end)
2869 j->write_buffer_wp = j->write_buffer;
2870 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2871 if (i) {
2872 j->flags.inwrite = 0;
2873 return -EFAULT;
2874 }
2875 if(j->play_codec == ALAW)
2876 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2877 j->flags.inwrite = 0;
2878 return min(count, j->write_buffer_size);
2879 }
2880
2881 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2882 {
2883 int pre_retval;
2884 ssize_t write_retval = 0;
2885
2886 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2887
2888 pre_retval = ixj_PreWrite(j, 0L);
2889 switch (pre_retval) {
2890 case NORMAL:
2891 write_retval = ixj_write(file_p, buf, count, ppos);
2892 if (write_retval > 0) {
2893 ixj_PostWrite(j, 0L);
2894 j->write_buffer_wp += write_retval;
2895 j->write_buffers_empty--;
2896 }
2897 break;
2898 case NOPOST:
2899 write_retval = ixj_write(file_p, buf, count, ppos);
2900 if (write_retval > 0) {
2901 j->write_buffer_wp += write_retval;
2902 j->write_buffers_empty--;
2903 }
2904 break;
2905 case POSTONLY:
2906 ixj_PostWrite(j, 0L);
2907 break;
2908 default:
2909 write_retval = pre_retval;
2910 }
2911 return write_retval;
2912 }
2913
2914 static void ixj_read_frame(IXJ *j)
2915 {
2916 int cnt, dly;
2917
2918 if (j->read_buffer) {
2919 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2920 if (!(cnt % 16) && !IsRxReady(j)) {
2921 dly = 0;
2922 while (!IsRxReady(j)) {
2923 if (dly++ > 5) {
2924 dly = 0;
2925 break;
2926 }
2927 udelay(10);
2928 }
2929 }
2930 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2931 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2932 inb_p(j->DSPbase + 0x0E);
2933 inb_p(j->DSPbase + 0x0F);
2934 }
2935 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2936 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2937 }
2938 ++j->framesread;
2939 if (j->intercom != -1) {
2940 if (IsTxReady(get_ixj(j->intercom))) {
2941 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2942 if (!(cnt % 16) && !IsTxReady(j)) {
2943 dly = 0;
2944 while (!IsTxReady(j)) {
2945 if (dly++ > 5) {
2946 dly = 0;
2947 break;
2948 }
2949 udelay(10);
2950 }
2951 }
2952 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2953 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2954 }
2955 get_ixj(j->intercom)->frameswritten++;
2956 }
2957 } else {
2958 j->read_buffer_ready = 1;
2959 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2960
2961 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2962
2963 if(j->ixj_signals[SIG_READ_READY])
2964 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2965 }
2966 }
2967 }
2968
2969 static short fsk[][6][20] =
2970 {
2971 {
2972 {
2973 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2974 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2975 },
2976 {
2977 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2978 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2979 },
2980 {
2981 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2982 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2983 },
2984 {
2985 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2986 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2987 },
2988 {
2989 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2990 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2991 },
2992 {
2993 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2994 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2995 }
2996 },
2997 {
2998 {
2999 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3000 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3001 },
3002 {
3003 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3004 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3005 },
3006 {
3007 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3008 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3009 },
3010 {
3011 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3012 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3013 },
3014 {
3015 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3016 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3017 },
3018 {
3019 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3020 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3021 }
3022 }
3023 };
3024
3025
3026 static void ixj_write_cid_bit(IXJ *j, int bit)
3027 {
3028 while (j->fskcnt < 20) {
3029 if(j->fskdcnt < (j->fsksize - 1))
3030 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3031
3032 j->fskcnt += 3;
3033 }
3034 j->fskcnt %= 20;
3035
3036 if (!bit)
3037 j->fskz++;
3038 if (j->fskz >= 6)
3039 j->fskz = 0;
3040
3041 }
3042
3043 static void ixj_write_cid_byte(IXJ *j, char byte)
3044 {
3045 IXJ_CBYTE cb;
3046
3047 cb.cbyte = byte;
3048 ixj_write_cid_bit(j, 0);
3049 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3055 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3056 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3057 ixj_write_cid_bit(j, 1);
3058 }
3059
3060 static void ixj_write_cid_seize(IXJ *j)
3061 {
3062 int cnt;
3063
3064 for (cnt = 0; cnt < 150; cnt++) {
3065 ixj_write_cid_bit(j, 0);
3066 ixj_write_cid_bit(j, 1);
3067 }
3068 for (cnt = 0; cnt < 180; cnt++) {
3069 ixj_write_cid_bit(j, 1);
3070 }
3071 }
3072
3073 static void ixj_write_cidcw_seize(IXJ *j)
3074 {
3075 int cnt;
3076
3077 for (cnt = 0; cnt < 80; cnt++) {
3078 ixj_write_cid_bit(j, 1);
3079 }
3080 }
3081
3082 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3083 {
3084 int cnt;
3085
3086 for (cnt = 0; cnt < strlen(s); cnt++) {
3087 ixj_write_cid_byte(j, s[cnt]);
3088 checksum = (checksum + s[cnt]);
3089 }
3090 return checksum;
3091 }
3092
3093 static void ixj_pad_fsk(IXJ *j, int pad)
3094 {
3095 int cnt;
3096
3097 for (cnt = 0; cnt < pad; cnt++) {
3098 if(j->fskdcnt < (j->fsksize - 1))
3099 j->fskdata[j->fskdcnt++] = 0x0000;
3100 }
3101 for (cnt = 0; cnt < 720; cnt++) {
3102 if(j->fskdcnt < (j->fsksize - 1))
3103 j->fskdata[j->fskdcnt++] = 0x0000;
3104 }
3105 }
3106
3107 static void ixj_pre_cid(IXJ *j)
3108 {
3109 j->cid_play_codec = j->play_codec;
3110 j->cid_play_frame_size = j->play_frame_size;
3111 j->cid_play_volume = get_play_volume(j);
3112 j->cid_play_flag = j->flags.playing;
3113
3114 j->cid_rec_codec = j->rec_codec;
3115 j->cid_rec_volume = get_rec_volume(j);
3116 j->cid_rec_flag = j->flags.recording;
3117
3118 j->cid_play_aec_level = j->aec_level;
3119
3120 switch(j->baseframe.low) {
3121 case 0xA0:
3122 j->cid_base_frame_size = 20;
3123 break;
3124 case 0x50:
3125 j->cid_base_frame_size = 10;
3126 break;
3127 case 0xF0:
3128 j->cid_base_frame_size = 30;
3129 break;
3130 }
3131
3132 ixj_play_stop(j);
3133 ixj_cpt_stop(j);
3134
3135 j->flags.cidplay = 1;
3136
3137 set_base_frame(j, 30);
3138 set_play_codec(j, LINEAR16);
3139 set_play_volume(j, 0x1B);
3140 ixj_play_start(j);
3141 }
3142
3143 static void ixj_post_cid(IXJ *j)
3144 {
3145 ixj_play_stop(j);
3146
3147 if(j->cidsize > 5000) {
3148 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3149 }
3150 j->flags.cidplay = 0;
3151 if(ixjdebug & 0x0200) {
3152 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3153 }
3154
3155 ixj_fsk_free(j);
3156
3157 j->fskdcnt = 0;
3158 set_base_frame(j, j->cid_base_frame_size);
3159 set_play_codec(j, j->cid_play_codec);
3160 ixj_aec_start(j, j->cid_play_aec_level);
3161 set_play_volume(j, j->cid_play_volume);
3162
3163 set_rec_codec(j, j->cid_rec_codec);
3164 set_rec_volume(j, j->cid_rec_volume);
3165
3166 if(j->cid_rec_flag)
3167 ixj_record_start(j);
3168
3169 if(j->cid_play_flag)
3170 ixj_play_start(j);
3171
3172 if(j->cid_play_flag) {
3173 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3174 }
3175 }
3176
3177 static void ixj_write_cid(IXJ *j)
3178 {
3179 char sdmf1[50];
3180 char sdmf2[50];
3181 char sdmf3[80];
3182 char mdmflen, len1, len2, len3;
3183 int pad;
3184
3185 int checksum = 0;
3186
3187 if (j->dsp.low == 0x20 || j->flags.cidplay)
3188 return;
3189
3190 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3191 j->cidsize = j->cidcnt = 0;
3192
3193 ixj_fsk_alloc(j);
3194
3195 strcpy(sdmf1, j->cid_send.month);
3196 strcat(sdmf1, j->cid_send.day);
3197 strcat(sdmf1, j->cid_send.hour);
3198 strcat(sdmf1, j->cid_send.min);
3199 strcpy(sdmf2, j->cid_send.number);
3200 strcpy(sdmf3, j->cid_send.name);
3201
3202 len1 = strlen(sdmf1);
3203 len2 = strlen(sdmf2);
3204 len3 = strlen(sdmf3);
3205 mdmflen = len1 + len2 + len3 + 6;
3206
3207 while(1){
3208 ixj_write_cid_seize(j);
3209
3210 ixj_write_cid_byte(j, 0x80);
3211 checksum = 0x80;
3212 ixj_write_cid_byte(j, mdmflen);
3213 checksum = checksum + mdmflen;
3214
3215 ixj_write_cid_byte(j, 0x01);
3216 checksum = checksum + 0x01;
3217 ixj_write_cid_byte(j, len1);
3218 checksum = checksum + len1;
3219 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3220 if(ixj_hookstate(j) & 1)
3221 break;
3222
3223 ixj_write_cid_byte(j, 0x02);
3224 checksum = checksum + 0x02;
3225 ixj_write_cid_byte(j, len2);
3226 checksum = checksum + len2;
3227 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3228 if(ixj_hookstate(j) & 1)
3229 break;
3230
3231 ixj_write_cid_byte(j, 0x07);
3232 checksum = checksum + 0x07;
3233 ixj_write_cid_byte(j, len3);
3234 checksum = checksum + len3;
3235 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3236 if(ixj_hookstate(j) & 1)
3237 break;
3238
3239 checksum %= 256;
3240 checksum ^= 0xFF;
3241 checksum += 1;
3242
3243 ixj_write_cid_byte(j, (char) checksum);
3244
3245 pad = j->fskdcnt % 240;
3246 if (pad) {
3247 pad = 240 - pad;
3248 }
3249 ixj_pad_fsk(j, pad);
3250 break;
3251 }
3252
3253 ixj_write_frame(j);
3254 }
3255
3256 static void ixj_write_cidcw(IXJ *j)
3257 {
3258 IXJ_TONE ti;
3259
3260 char sdmf1[50];
3261 char sdmf2[50];
3262 char sdmf3[80];
3263 char mdmflen, len1, len2, len3;
3264 int pad;
3265
3266 int checksum = 0;
3267
3268 if (j->dsp.low == 0x20 || j->flags.cidplay)
3269 return;
3270
3271 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3272 j->cidsize = j->cidcnt = 0;
3273
3274 ixj_fsk_alloc(j);
3275
3276 j->flags.cidcw_ack = 0;
3277
3278 ti.tone_index = 23;
3279 ti.gain0 = 1;
3280 ti.freq0 = hz440;
3281 ti.gain1 = 0;
3282 ti.freq1 = 0;
3283 ixj_init_tone(j, &ti);
3284
3285 ixj_set_tone_on(1500, j);
3286 ixj_set_tone_off(32, j);
3287 if(ixjdebug & 0x0200) {
3288 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3289 }
3290 ixj_play_tone(j, 23);
3291
3292 clear_bit(j->board, &j->busyflags);
3293 while(j->tone_state)
3294 schedule_timeout_interruptible(1);
3295 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3296 schedule_timeout_interruptible(1);
3297 if(ixjdebug & 0x0200) {
3298 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3299 }
3300
3301 ti.tone_index = 24;
3302 ti.gain0 = 1;
3303 ti.freq0 = hz2130;
3304 ti.gain1 = 0;
3305 ti.freq1 = hz2750;
3306 ixj_init_tone(j, &ti);
3307
3308 ixj_set_tone_off(10, j);
3309 ixj_set_tone_on(600, j);
3310 if(ixjdebug & 0x0200) {
3311 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3312 }
3313 ixj_play_tone(j, 24);
3314
3315 clear_bit(j->board, &j->busyflags);
3316 while(j->tone_state)
3317 schedule_timeout_interruptible(1);
3318 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3319 schedule_timeout_interruptible(1);
3320 if(ixjdebug & 0x0200) {
3321 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3322 }
3323
3324 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3325
3326 clear_bit(j->board, &j->busyflags);
3327 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3328 schedule_timeout_interruptible(1);
3329 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3330 schedule_timeout_interruptible(1);
3331 j->cidcw_wait = 0;
3332 if(!j->flags.cidcw_ack) {
3333 if(ixjdebug & 0x0200) {
3334 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3335 }
3336 ixj_post_cid(j);
3337 if(j->cid_play_flag) {
3338 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3339 }
3340 return;
3341 } else {
3342 ixj_pre_cid(j);
3343 }
3344 j->flags.cidcw_ack = 0;
3345 strcpy(sdmf1, j->cid_send.month);
3346 strcat(sdmf1, j->cid_send.day);
3347 strcat(sdmf1, j->cid_send.hour);
3348 strcat(sdmf1, j->cid_send.min);
3349 strcpy(sdmf2, j->cid_send.number);
3350 strcpy(sdmf3, j->cid_send.name);
3351
3352 len1 = strlen(sdmf1);
3353 len2 = strlen(sdmf2);
3354 len3 = strlen(sdmf3);
3355 mdmflen = len1 + len2 + len3 + 6;
3356
3357 ixj_write_cidcw_seize(j);
3358
3359 ixj_write_cid_byte(j, 0x80);
3360 checksum = 0x80;
3361 ixj_write_cid_byte(j, mdmflen);
3362 checksum = checksum + mdmflen;
3363
3364 ixj_write_cid_byte(j, 0x01);
3365 checksum = checksum + 0x01;
3366 ixj_write_cid_byte(j, len1);
3367 checksum = checksum + len1;
3368 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3369
3370 ixj_write_cid_byte(j, 0x02);
3371 checksum = checksum + 0x02;
3372 ixj_write_cid_byte(j, len2);
3373 checksum = checksum + len2;
3374 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3375
3376 ixj_write_cid_byte(j, 0x07);
3377 checksum = checksum + 0x07;
3378 ixj_write_cid_byte(j, len3);
3379 checksum = checksum + len3;
3380 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3381
3382 checksum %= 256;
3383 checksum ^= 0xFF;
3384 checksum += 1;
3385
3386 ixj_write_cid_byte(j, (char) checksum);
3387
3388 pad = j->fskdcnt % 240;
3389 if (pad) {
3390 pad = 240 - pad;
3391 }
3392 ixj_pad_fsk(j, pad);
3393 if(ixjdebug & 0x0200) {
3394 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3395 }
3396 }
3397
3398 static void ixj_write_vmwi(IXJ *j, int msg)
3399 {
3400 char mdmflen;
3401 int pad;
3402
3403 int checksum = 0;
3404
3405 if (j->dsp.low == 0x20 || j->flags.cidplay)
3406 return;
3407
3408 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3409 j->cidsize = j->cidcnt = 0;
3410
3411 ixj_fsk_alloc(j);
3412
3413 mdmflen = 3;
3414
3415 if (j->port == PORT_POTS)
3416 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3417
3418 ixj_write_cid_seize(j);
3419
3420 ixj_write_cid_byte(j, 0x82);
3421 checksum = 0x82;
3422 ixj_write_cid_byte(j, mdmflen);
3423 checksum = checksum + mdmflen;
3424
3425 ixj_write_cid_byte(j, 0x0B);
3426 checksum = checksum + 0x0B;
3427 ixj_write_cid_byte(j, 1);
3428 checksum = checksum + 1;
3429
3430 if(msg) {
3431 ixj_write_cid_byte(j, 0xFF);
3432 checksum = checksum + 0xFF;
3433 }
3434 else {
3435 ixj_write_cid_byte(j, 0x00);
3436 checksum = checksum + 0x00;
3437 }
3438
3439 checksum %= 256;
3440 checksum ^= 0xFF;
3441 checksum += 1;
3442
3443 ixj_write_cid_byte(j, (char) checksum);
3444
3445 pad = j->fskdcnt % 240;
3446 if (pad) {
3447 pad = 240 - pad;
3448 }
3449 ixj_pad_fsk(j, pad);
3450 }
3451
3452 static void ixj_write_frame(IXJ *j)
3453 {
3454 int cnt, frame_count, dly;
3455 IXJ_WORD dat;
3456
3457 frame_count = 0;
3458 if(j->flags.cidplay) {
3459 for(cnt = 0; cnt < 480; cnt++) {
3460 if (!(cnt % 16) && !IsTxReady(j)) {
3461 dly = 0;
3462 while (!IsTxReady(j)) {
3463 if (dly++ > 5) {
3464 dly = 0;
3465 break;
3466 }
3467 udelay(10);
3468 }
3469 }
3470 dat.word = j->fskdata[j->cidcnt++];
3471 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3472 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3473 cnt++;
3474 }
3475 if(j->cidcnt >= j->fskdcnt) {
3476 ixj_post_cid(j);
3477 }
3478 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3479 and there is real audio data in the buffer, we need to throw it away because
3480 we just used it's time slot */
3481 if (j->write_buffer_rp > j->write_buffer_wp) {
3482 j->write_buffer_rp += j->cid_play_frame_size * 2;
3483 if (j->write_buffer_rp >= j->write_buffer_end) {
3484 j->write_buffer_rp = j->write_buffer;
3485 }
3486 j->write_buffers_empty++;
3487 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3488
3489 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3490 }
3491 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3492 if (j->write_buffer_wp > j->write_buffer_rp) {
3493 frame_count =
3494 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3495 }
3496 if (j->write_buffer_rp > j->write_buffer_wp) {
3497 frame_count =
3498 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3499 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3500 }
3501 if (frame_count >= 1) {
3502 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3503 BYTES blankword;
3504
3505 switch (j->play_mode) {
3506 case PLAYBACK_MODE_ULAW:
3507 case PLAYBACK_MODE_ALAW:
3508 blankword.low = blankword.high = 0xFF;
3509 break;
3510 case PLAYBACK_MODE_8LINEAR:
3511 case PLAYBACK_MODE_16LINEAR:
3512 default:
3513 blankword.low = blankword.high = 0x00;
3514 break;
3515 case PLAYBACK_MODE_8LINEAR_WSS:
3516 blankword.low = blankword.high = 0x80;
3517 break;
3518 }
3519 for (cnt = 0; cnt < 16; cnt++) {
3520 if (!(cnt % 16) && !IsTxReady(j)) {
3521 dly = 0;
3522 while (!IsTxReady(j)) {
3523 if (dly++ > 5) {
3524 dly = 0;
3525 break;
3526 }
3527 udelay(10);
3528 }
3529 }
3530 outb_p((blankword.low), j->DSPbase + 0x0C);
3531 outb_p((blankword.high), j->DSPbase + 0x0D);
3532 }
3533 j->flags.play_first_frame = 0;
3534 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3535 for (cnt = 0; cnt < 24; cnt++) {
3536 BYTES blankword;
3537
3538 if(cnt == 12) {
3539 blankword.low = 0x02;
3540 blankword.high = 0x00;
3541 }
3542 else {
3543 blankword.low = blankword.high = 0x00;
3544 }
3545 if (!(cnt % 16) && !IsTxReady(j)) {
3546 dly = 0;
3547 while (!IsTxReady(j)) {
3548 if (dly++ > 5) {
3549 dly = 0;
3550 break;
3551 }
3552 udelay(10);
3553 }
3554 }
3555 outb_p((blankword.low), j->DSPbase + 0x0C);
3556 outb_p((blankword.high), j->DSPbase + 0x0D);
3557 }
3558 j->flags.play_first_frame = 0;
3559 }
3560 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3561 if (!(cnt % 16) && !IsTxReady(j)) {
3562 dly = 0;
3563 while (!IsTxReady(j)) {
3564 if (dly++ > 5) {
3565 dly = 0;
3566 break;
3567 }
3568 udelay(10);
3569 }
3570 }
3571 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3572 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3573 if (j->write_buffer_rp[cnt] == 0 &&
3574 j->write_buffer_rp[cnt + 1] == 0 &&
3575 j->write_buffer_rp[cnt + 2] == 0 &&
3576 j->write_buffer_rp[cnt + 3] == 0 &&
3577 j->write_buffer_rp[cnt + 4] == 0 &&
3578 j->write_buffer_rp[cnt + 5] == 0 &&
3579 j->write_buffer_rp[cnt + 6] == 0 &&
3580 j->write_buffer_rp[cnt + 7] == 0 &&
3581 j->write_buffer_rp[cnt + 8] == 0 &&
3582 j->write_buffer_rp[cnt + 9] == 0) {
3583 /* someone is trying to write silence lets make this a type 0 frame. */
3584 outb_p(0x00, j->DSPbase + 0x0C);
3585 outb_p(0x00, j->DSPbase + 0x0D);
3586 } else {
3587 /* so all other frames are type 1. */
3588 outb_p(0x01, j->DSPbase + 0x0C);
3589 outb_p(0x00, j->DSPbase + 0x0D);
3590 }
3591 }
3592 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3593 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3594 *(j->write_buffer_rp + cnt) = 0;
3595 *(j->write_buffer_rp + cnt + 1) = 0;
3596 }
3597 j->write_buffer_rp += j->play_frame_size * 2;
3598 if (j->write_buffer_rp >= j->write_buffer_end) {
3599 j->write_buffer_rp = j->write_buffer;
3600 }
3601 j->write_buffers_empty++;
3602 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3603
3604 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3605
3606 ++j->frameswritten;
3607 }
3608 } else {
3609 j->drybuffer++;
3610 }
3611 if(j->ixj_signals[SIG_WRITE_READY]) {
3612 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3613 }
3614 }
3615
3616 static int idle(IXJ *j)
3617 {
3618 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3619
3620 return 0;
3621
3622 if (j->ssr.high || j->ssr.low) {
3623 return 0;
3624 } else {
3625 j->play_mode = -1;
3626 j->flags.playing = 0;
3627 j->rec_mode = -1;
3628 j->flags.recording = 0;
3629 return 1;
3630 }
3631 }
3632
3633 static int set_base_frame(IXJ *j, int size)
3634 {
3635 unsigned short cmd;
3636 int cnt;
3637
3638 idle(j);
3639 j->cid_play_aec_level = j->aec_level;
3640 aec_stop(j);
3641 for (cnt = 0; cnt < 10; cnt++) {
3642 if (idle(j))
3643 break;
3644 }
3645 if (j->ssr.high || j->ssr.low)
3646 return -1;
3647 if (j->dsp.low != 0x20) {
3648 switch (size) {
3649 case 30:
3650 cmd = 0x07F0;
3651 /* Set Base Frame Size to 240 pg9-10 8021 */
3652 break;
3653 case 20:
3654 cmd = 0x07A0;
3655 /* Set Base Frame Size to 160 pg9-10 8021 */
3656 break;
3657 case 10:
3658 cmd = 0x0750;
3659 /* Set Base Frame Size to 80 pg9-10 8021 */
3660 break;
3661 default:
3662 return -1;
3663 }
3664 } else {
3665 if (size == 30)
3666 return size;
3667 else
3668 return -1;
3669 }
3670 if (ixj_WriteDSPCommand(cmd, j)) {
3671 j->baseframe.high = j->baseframe.low = 0xFF;
3672 return -1;
3673 } else {
3674 j->baseframe.high = j->ssr.high;
3675 j->baseframe.low = j->ssr.low;
3676 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3677 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3678 return -1;
3679 }
3680 }
3681 ixj_aec_start(j, j->cid_play_aec_level);
3682 return size;
3683 }
3684
3685 static int set_rec_codec(IXJ *j, int rate)
3686 {
3687 int retval = 0;
3688
3689 j->rec_codec = rate;
3690
3691 switch (rate) {
3692 case G723_63:
3693 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3694 j->rec_frame_size = 12;
3695 j->rec_mode = 0;
3696 } else {
3697 retval = 1;
3698 }
3699 break;
3700 case G723_53:
3701 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3702 j->rec_frame_size = 10;
3703 j->rec_mode = 0;
3704 } else {
3705 retval = 1;
3706 }
3707 break;
3708 case TS85:
3709 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3710 j->rec_frame_size = 16;
3711 j->rec_mode = 0;
3712 } else {
3713 retval = 1;
3714 }
3715 break;
3716 case TS48:
3717 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3718 j->rec_frame_size = 9;
3719 j->rec_mode = 0;
3720 } else {
3721 retval = 1;
3722 }
3723 break;
3724 case TS41:
3725 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3726 j->rec_frame_size = 8;
3727 j->rec_mode = 0;
3728 } else {
3729 retval = 1;
3730 }
3731 break;
3732 case G728:
3733 if (j->dsp.low != 0x20) {
3734 j->rec_frame_size = 48;
3735 j->rec_mode = 0;
3736 } else {
3737 retval = 1;
3738 }
3739 break;
3740 case G729:
3741 if (j->dsp.low != 0x20) {
3742 if (!j->flags.g729_loaded) {
3743 retval = 1;
3744 break;
3745 }
3746 switch (j->baseframe.low) {
3747 case 0xA0:
3748 j->rec_frame_size = 10;
3749 break;
3750 case 0x50:
3751 j->rec_frame_size = 5;
3752 break;
3753 default:
3754 j->rec_frame_size = 15;
3755 break;
3756 }
3757 j->rec_mode = 0;
3758 } else {
3759 retval = 1;
3760 }
3761 break;
3762 case G729B:
3763 if (j->dsp.low != 0x20) {
3764 if (!j->flags.g729_loaded) {
3765 retval = 1;
3766 break;
3767 }
3768 switch (j->baseframe.low) {
3769 case 0xA0:
3770 j->rec_frame_size = 12;
3771 break;
3772 case 0x50:
3773 j->rec_frame_size = 6;
3774 break;
3775 default:
3776 j->rec_frame_size = 18;
3777 break;
3778 }
3779 j->rec_mode = 0;
3780 } else {
3781 retval = 1;
3782 }
3783 break;
3784 case ULAW:
3785 switch (j->baseframe.low) {
3786 case 0xA0:
3787 j->rec_frame_size = 80;
3788 break;
3789 case 0x50:
3790 j->rec_frame_size = 40;
3791 break;
3792 default:
3793 j->rec_frame_size = 120;
3794 break;
3795 }
3796 j->rec_mode = 4;
3797 break;
3798 case ALAW:
3799 switch (j->baseframe.low) {
3800 case 0xA0:
3801 j->rec_frame_size = 80;
3802 break;
3803 case 0x50:
3804 j->rec_frame_size = 40;
3805 break;
3806 default:
3807 j->rec_frame_size = 120;
3808 break;
3809 }
3810 j->rec_mode = 4;
3811 break;
3812 case LINEAR16:
3813 switch (j->baseframe.low) {
3814 case 0xA0:
3815 j->rec_frame_size = 160;
3816 break;
3817 case 0x50:
3818 j->rec_frame_size = 80;
3819 break;
3820 default:
3821 j->rec_frame_size = 240;
3822 break;
3823 }
3824 j->rec_mode = 5;
3825 break;
3826 case LINEAR8:
3827 switch (j->baseframe.low) {
3828 case 0xA0:
3829 j->rec_frame_size = 80;
3830 break;
3831 case 0x50:
3832 j->rec_frame_size = 40;
3833 break;
3834 default:
3835 j->rec_frame_size = 120;
3836 break;
3837 }
3838 j->rec_mode = 6;
3839 break;
3840 case WSS:
3841 switch (j->baseframe.low) {
3842 case 0xA0:
3843 j->rec_frame_size = 80;
3844 break;
3845 case 0x50:
3846 j->rec_frame_size = 40;
3847 break;
3848 default:
3849 j->rec_frame_size = 120;
3850 break;
3851 }
3852 j->rec_mode = 7;
3853 break;
3854 default:
3855 kfree(j->read_buffer);
3856 j->rec_frame_size = 0;
3857 j->rec_mode = -1;
3858 j->read_buffer = NULL;
3859 j->read_buffer_size = 0;
3860 retval = 1;
3861 break;
3862 }
3863 return retval;
3864 }
3865
3866 static int ixj_record_start(IXJ *j)
3867 {
3868 unsigned short cmd = 0x0000;
3869
3870 if (j->read_buffer) {
3871 ixj_record_stop(j);
3872 }
3873 j->flags.recording = 1;
3874 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3875
3876 if(ixjdebug & 0x0002)
3877 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3878
3879 if (!j->rec_mode) {
3880 switch (j->rec_codec) {
3881 case G723_63:
3882 cmd = 0x5131;
3883 break;
3884 case G723_53:
3885 cmd = 0x5132;
3886 break;
3887 case TS85:
3888 cmd = 0x5130; /* TrueSpeech 8.5 */
3889
3890 break;
3891 case TS48:
3892 cmd = 0x5133; /* TrueSpeech 4.8 */
3893
3894 break;
3895 case TS41:
3896 cmd = 0x5134; /* TrueSpeech 4.1 */
3897
3898 break;
3899 case G728:
3900 cmd = 0x5135;
3901 break;
3902 case G729:
3903 case G729B:
3904 cmd = 0x5136;
3905 break;
3906 default:
3907 return 1;
3908 }
3909 if (ixj_WriteDSPCommand(cmd, j))
3910 return -1;
3911 }
3912 if (!j->read_buffer) {
3913 if (!j->read_buffer)
3914 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3915 if (!j->read_buffer) {
3916 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3917 return -ENOMEM;
3918 }
3919 }
3920 j->read_buffer_size = j->rec_frame_size * 2;
3921
3922 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3923
3924 return -1;
3925
3926 switch (j->rec_mode) {
3927 case 0:
3928 cmd = 0x1C03; /* Record C1 */
3929
3930 break;
3931 case 4:
3932 if (j->ver.low == 0x12) {
3933 cmd = 0x1E03; /* Record C1 */
3934
3935 } else {
3936 cmd = 0x1E01; /* Record C1 */
3937
3938 }
3939 break;
3940 case 5:
3941 if (j->ver.low == 0x12) {
3942 cmd = 0x1E83; /* Record C1 */
3943
3944 } else {
3945 cmd = 0x1E81; /* Record C1 */
3946
3947 }
3948 break;
3949 case 6:
3950 if (j->ver.low == 0x12) {
3951 cmd = 0x1F03; /* Record C1 */
3952
3953 } else {
3954 cmd = 0x1F01; /* Record C1 */
3955
3956 }
3957 break;
3958 case 7:
3959 if (j->ver.low == 0x12) {
3960 cmd = 0x1F83; /* Record C1 */
3961 } else {
3962 cmd = 0x1F81; /* Record C1 */
3963 }
3964 break;
3965 }
3966 if (ixj_WriteDSPCommand(cmd, j))
3967 return -1;
3968
3969 if (j->flags.playing) {
3970 ixj_aec_start(j, j->aec_level);
3971 }
3972 return 0;
3973 }
3974
3975 static void ixj_record_stop(IXJ *j)
3976 {
3977 if (ixjdebug & 0x0002)
3978 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3979
3980 kfree(j->read_buffer);
3981 j->read_buffer = NULL;
3982 j->read_buffer_size = 0;
3983 if (j->rec_mode > -1) {
3984 ixj_WriteDSPCommand(0x5120, j);
3985 j->rec_mode = -1;
3986 }
3987 j->flags.recording = 0;
3988 }
3989 static void ixj_vad(IXJ *j, int arg)
3990 {
3991 if (arg)
3992 ixj_WriteDSPCommand(0x513F, j);
3993 else
3994 ixj_WriteDSPCommand(0x513E, j);
3995 }
3996
3997 static void set_rec_depth(IXJ *j, int depth)
3998 {
3999 if (depth > 60)
4000 depth = 60;
4001 if (depth < 0)
4002 depth = 0;
4003 ixj_WriteDSPCommand(0x5180 + depth, j);
4004 }
4005
4006 static void set_dtmf_prescale(IXJ *j, int volume)
4007 {
4008 ixj_WriteDSPCommand(0xCF07, j);
4009 ixj_WriteDSPCommand(volume, j);
4010 }
4011
4012 static int get_dtmf_prescale(IXJ *j)
4013 {
4014 ixj_WriteDSPCommand(0xCF05, j);
4015 return j->ssr.high << 8 | j->ssr.low;
4016 }
4017
4018 static void set_rec_volume(IXJ *j, int volume)
4019 {
4020 if(j->aec_level == AEC_AGC) {
4021 if (ixjdebug & 0x0002)
4022 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4023 ixj_WriteDSPCommand(0xCF96, j);
4024 ixj_WriteDSPCommand(volume, j);
4025 } else {
4026 if (ixjdebug & 0x0002)
4027 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4028 ixj_WriteDSPCommand(0xCF03, j);
4029 ixj_WriteDSPCommand(volume, j);
4030 }
4031 }
4032
4033 static int set_rec_volume_linear(IXJ *j, int volume)
4034 {
4035 int newvolume, dsprecmax;
4036
4037 if (ixjdebug & 0x0002)
4038 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4039 if(volume > 100 || volume < 0) {
4040 return -1;
4041 }
4042
4043 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4044 switch (j->cardtype) {
4045 case QTI_PHONEJACK:
4046 dsprecmax = 0x440;
4047 break;
4048 case QTI_LINEJACK:
4049 dsprecmax = 0x180;
4050 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4051 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4052 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4053 break;
4054 case QTI_PHONEJACK_LITE:
4055 dsprecmax = 0x4C0;
4056 break;
4057 case QTI_PHONEJACK_PCI:
4058 dsprecmax = 0x100;
4059 break;
4060 case QTI_PHONECARD:
4061 dsprecmax = 0x400;
4062 break;
4063 default:
4064 return -1;
4065 }
4066 newvolume = (dsprecmax * volume) / 100;
4067 set_rec_volume(j, newvolume);
4068 return 0;
4069 }
4070
4071 static int get_rec_volume(IXJ *j)
4072 {
4073 if(j->aec_level == AEC_AGC) {
4074 if (ixjdebug & 0x0002)
4075 printk(KERN_INFO "Getting AGC Threshold\n");
4076 ixj_WriteDSPCommand(0xCF86, j);
4077 if (ixjdebug & 0x0002)
4078 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4079 return j->ssr.high << 8 | j->ssr.low;
4080 } else {
4081 if (ixjdebug & 0x0002)
4082 printk(KERN_INFO "Getting Record Volume\n");
4083 ixj_WriteDSPCommand(0xCF01, j);
4084 return j->ssr.high << 8 | j->ssr.low;
4085 }
4086 }
4087
4088 static int get_rec_volume_linear(IXJ *j)
4089 {
4090 int volume, newvolume, dsprecmax;
4091
4092 switch (j->cardtype) {
4093 case QTI_PHONEJACK:
4094 dsprecmax = 0x440;
4095 break;
4096 case QTI_LINEJACK:
4097 dsprecmax = 0x180;
4098 break;
4099 case QTI_PHONEJACK_LITE:
4100 dsprecmax = 0x4C0;
4101 break;
4102 case QTI_PHONEJACK_PCI:
4103 dsprecmax = 0x100;
4104 break;
4105 case QTI_PHONECARD:
4106 dsprecmax = 0x400;
4107 break;
4108 default:
4109 return -1;
4110 }
4111 volume = get_rec_volume(j);
4112 newvolume = (volume * 100) / dsprecmax;
4113 if(newvolume > 100)
4114 newvolume = 100;
4115 return newvolume;
4116 }
4117
4118 static int get_rec_level(IXJ *j)
4119 {
4120 int retval;
4121
4122 ixj_WriteDSPCommand(0xCF88, j);
4123
4124 retval = j->ssr.high << 8 | j->ssr.low;
4125 retval = (retval * 256) / 240;
4126 return retval;
4127 }
4128
4129 static void ixj_aec_start(IXJ *j, int level)
4130 {
4131 j->aec_level = level;
4132 if (ixjdebug & 0x0002)
4133 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4134 if (!level) {
4135 aec_stop(j);
4136 } else {
4137 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4138 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4139
4140 ixj_WriteDSPCommand(0x0300, j);
4141 }
4142 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4143
4144 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4145
4146 switch (level) {
4147 case AEC_LOW:
4148 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4149
4150 ixj_WriteDSPCommand(0xE011, j);
4151 ixj_WriteDSPCommand(0xFFFF, j);
4152
4153 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4154 ixj_WriteDSPCommand(0x0000, j); /* to off */
4155
4156 break;
4157
4158 case AEC_MED:
4159 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4160
4161 ixj_WriteDSPCommand(0xE011, j);
4162 ixj_WriteDSPCommand(0x0080, j);
4163
4164 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4165 ixj_WriteDSPCommand(0x0000, j); /* to off */
4166
4167 break;
4168
4169 case AEC_HIGH:
4170 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4171
4172 ixj_WriteDSPCommand(0xE011, j);
4173 ixj_WriteDSPCommand(0x0080, j);
4174
4175 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4176 ixj_WriteDSPCommand(0x0000, j); /* to off */
4177
4178 break;
4179
4180 case AEC_AGC:
4181 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4182 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4183
4184 ixj_WriteDSPCommand(0xE011, j);
4185 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4186
4187 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4188
4189 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4190 ixj_WriteDSPCommand(0x0224, j);
4191 else
4192 ixj_WriteDSPCommand(0x1224, j);
4193
4194 ixj_WriteDSPCommand(0xE014, j);
4195 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4196
4197 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4198
4199 /* Now we can set the AGC initial parameters and turn it on */
4200 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4201 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4202
4203 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4204 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4205
4206 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4207 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4208
4209 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4210 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4211
4212 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4213 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4214
4215 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4216 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4217
4218 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4219 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4220
4221 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4222 ixj_WriteDSPCommand(0x0001, j); /* to on */
4223
4224 break;
4225
4226 case AEC_AUTO:
4227 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4228
4229 ixj_WriteDSPCommand(0xE011, j);
4230 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4231
4232 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4233
4234 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4235 ixj_WriteDSPCommand(0x0224, j);
4236 else
4237 ixj_WriteDSPCommand(0x1224, j);
4238
4239 ixj_WriteDSPCommand(0xE014, j);
4240 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4241
4242 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4243
4244 break;
4245 }
4246 }
4247 }
4248
4249 static void aec_stop(IXJ *j)
4250 {
4251 j->aec_level = AEC_OFF;
4252 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4253 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4254
4255 ixj_WriteDSPCommand(0x0700, j);
4256 }
4257 if (j->play_mode != -1 && j->rec_mode != -1)
4258 {
4259 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4260 }
4261 }
4262
4263 static int set_play_codec(IXJ *j, int rate)
4264 {
4265 int retval = 0;
4266
4267 j->play_codec = rate;
4268
4269 switch (rate) {
4270 case G723_63:
4271 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4272 j->play_frame_size = 12;
4273 j->play_mode = 0;
4274 } else {
4275 retval = 1;
4276 }
4277 break;
4278 case G723_53:
4279 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4280 j->play_frame_size = 10;
4281 j->play_mode = 0;
4282 } else {
4283 retval = 1;
4284 }
4285 break;
4286 case TS85:
4287 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4288 j->play_frame_size = 16;
4289 j->play_mode = 0;
4290 } else {
4291 retval = 1;
4292 }
4293 break;
4294 case TS48:
4295 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4296 j->play_frame_size = 9;
4297 j->play_mode = 0;
4298 } else {
4299 retval = 1;
4300 }
4301 break;
4302 case TS41:
4303 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4304 j->play_frame_size = 8;
4305 j->play_mode = 0;
4306 } else {
4307 retval = 1;
4308 }
4309 break;
4310 case G728:
4311 if (j->dsp.low != 0x20) {
4312 j->play_frame_size = 48;
4313 j->play_mode = 0;
4314 } else {
4315 retval = 1;
4316 }
4317 break;
4318 case G729:
4319 if (j->dsp.low != 0x20) {
4320 if (!j->flags.g729_loaded) {
4321 retval = 1;
4322 break;
4323 }
4324 switch (j->baseframe.low) {
4325 case 0xA0:
4326 j->play_frame_size = 10;
4327 break;
4328 case 0x50:
4329 j->play_frame_size = 5;
4330 break;
4331 default:
4332 j->play_frame_size = 15;
4333 break;
4334 }
4335 j->play_mode = 0;
4336 } else {
4337 retval = 1;
4338 }
4339 break;
4340 case G729B:
4341 if (j->dsp.low != 0x20) {
4342 if (!j->flags.g729_loaded) {
4343 retval = 1;
4344 break;
4345 }
4346 switch (j->baseframe.low) {
4347 case 0xA0:
4348 j->play_frame_size = 12;
4349 break;
4350 case 0x50:
4351 j->play_frame_size = 6;
4352 break;
4353 default:
4354 j->play_frame_size = 18;
4355 break;
4356 }
4357 j->play_mode = 0;
4358 } else {
4359 retval = 1;
4360 }
4361 break;
4362 case ULAW:
4363 switch (j->baseframe.low) {
4364 case 0xA0:
4365 j->play_frame_size = 80;
4366 break;
4367 case 0x50:
4368 j->play_frame_size = 40;
4369 break;
4370 default:
4371 j->play_frame_size = 120;
4372 break;
4373 }
4374 j->play_mode = 2;
4375 break;
4376 case ALAW:
4377 switch (j->baseframe.low) {
4378 case 0xA0:
4379 j->play_frame_size = 80;
4380 break;
4381 case 0x50:
4382 j->play_frame_size = 40;
4383 break;
4384 default:
4385 j->play_frame_size = 120;
4386 break;
4387 }
4388 j->play_mode = 2;
4389 break;
4390 case LINEAR16:
4391 switch (j->baseframe.low) {
4392 case 0xA0:
4393 j->play_frame_size = 160;
4394 break;
4395 case 0x50:
4396 j->play_frame_size = 80;
4397 break;
4398 default:
4399 j->play_frame_size = 240;
4400 break;
4401 }
4402 j->play_mode = 6;
4403 break;
4404 case LINEAR8:
4405 switch (j->baseframe.low) {
4406 case 0xA0:
4407 j->play_frame_size = 80;
4408 break;
4409 case 0x50:
4410 j->play_frame_size = 40;
4411 break;
4412 default:
4413 j->play_frame_size = 120;
4414 break;
4415 }
4416 j->play_mode = 4;
4417 break;
4418 case WSS:
4419 switch (j->baseframe.low) {
4420 case 0xA0:
4421 j->play_frame_size = 80;
4422 break;
4423 case 0x50:
4424 j->play_frame_size = 40;
4425 break;
4426 default:
4427 j->play_frame_size = 120;
4428 break;
4429 }
4430 j->play_mode = 5;
4431 break;
4432 default:
4433 kfree(j->write_buffer);
4434 j->play_frame_size = 0;
4435 j->play_mode = -1;
4436 j->write_buffer = NULL;
4437 j->write_buffer_size = 0;
4438 retval = 1;
4439 break;
4440 }
4441 return retval;
4442 }
4443
4444 static int ixj_play_start(IXJ *j)
4445 {
4446 unsigned short cmd = 0x0000;
4447
4448 if (j->write_buffer) {
4449 ixj_play_stop(j);
4450 }
4451
4452 if(ixjdebug & 0x0002)
4453 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4454
4455 j->flags.playing = 1;
4456 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4457
4458 j->flags.play_first_frame = 1;
4459 j->drybuffer = 0;
4460
4461 if (!j->play_mode) {
4462 switch (j->play_codec) {
4463 case G723_63:
4464 cmd = 0x5231;
4465 break;
4466 case G723_53:
4467 cmd = 0x5232;
4468 break;
4469 case TS85:
4470 cmd = 0x5230; /* TrueSpeech 8.5 */
4471
4472 break;
4473 case TS48:
4474 cmd = 0x5233; /* TrueSpeech 4.8 */
4475
4476 break;
4477 case TS41:
4478 cmd = 0x5234; /* TrueSpeech 4.1 */
4479
4480 break;
4481 case G728:
4482 cmd = 0x5235;
4483 break;
4484 case G729:
4485 case G729B:
4486 cmd = 0x5236;
4487 break;
4488 default:
4489 return 1;
4490 }
4491 if (ixj_WriteDSPCommand(cmd, j))
4492 return -1;
4493 }
4494 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4495 if (!j->write_buffer) {
4496 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4497 return -ENOMEM;
4498 }
4499 /* j->write_buffers_empty = 2; */
4500 j->write_buffers_empty = 1;
4501 j->write_buffer_size = j->play_frame_size * 2;
4502 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4503 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4504
4505 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4506
4507 return -1;
4508
4509 switch (j->play_mode) {
4510 case 0:
4511 cmd = 0x2C03;
4512 break;
4513 case 2:
4514 if (j->ver.low == 0x12) {
4515 cmd = 0x2C23;
4516 } else {
4517 cmd = 0x2C21;
4518 }
4519 break;
4520 case 4:
4521 if (j->ver.low == 0x12) {
4522 cmd = 0x2C43;
4523 } else {
4524 cmd = 0x2C41;
4525 }
4526 break;
4527 case 5:
4528 if (j->ver.low == 0x12) {
4529 cmd = 0x2C53;
4530 } else {
4531 cmd = 0x2C51;
4532 }
4533 break;
4534 case 6:
4535 if (j->ver.low == 0x12) {
4536 cmd = 0x2C63;
4537 } else {
4538 cmd = 0x2C61;
4539 }
4540 break;
4541 }
4542 if (ixj_WriteDSPCommand(cmd, j))
4543 return -1;
4544
4545 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4546 return -1;
4547
4548 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4549 return -1;
4550
4551 if (j->flags.recording) {
4552 ixj_aec_start(j, j->aec_level);
4553 }
4554
4555 return 0;
4556 }
4557
4558 static void ixj_play_stop(IXJ *j)
4559 {
4560 if (ixjdebug & 0x0002)
4561 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4562
4563 kfree(j->write_buffer);
4564 j->write_buffer = NULL;
4565 j->write_buffer_size = 0;
4566 if (j->play_mode > -1) {
4567 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4568
4569 j->play_mode = -1;
4570 }
4571 j->flags.playing = 0;
4572 }
4573
4574 static inline int get_play_level(IXJ *j)
4575 {
4576 int retval;
4577
4578 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4579 return j->ssr.high << 8 | j->ssr.low;
4580 retval = j->ssr.high << 8 | j->ssr.low;
4581 retval = (retval * 256) / 240;
4582 return retval;
4583 }
4584
4585 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4586 {
4587 unsigned int mask = 0;
4588
4589 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4590
4591 poll_wait(file_p, &(j->poll_q), wait);
4592 if (j->read_buffer_ready > 0)
4593 mask |= POLLIN | POLLRDNORM; /* readable */
4594 if (j->write_buffers_empty > 0)
4595 mask |= POLLOUT | POLLWRNORM; /* writable */
4596 if (j->ex.bytes)
4597 mask |= POLLPRI;
4598 return mask;
4599 }
4600
4601 static int ixj_play_tone(IXJ *j, char tone)
4602 {
4603 if (!j->tone_state) {
4604 if(ixjdebug & 0x0002) {
4605 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4606 }
4607 if (j->dsp.low == 0x20) {
4608 idle(j);
4609 }
4610 j->tone_start_jif = jiffies;
4611
4612 j->tone_state = 1;
4613 }
4614
4615 j->tone_index = tone;
4616 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4617 return -1;
4618
4619 return 0;
4620 }
4621
4622 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4623 {
4624 j->tone_on_time = arg;
4625
4626 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4627
4628 return -1;
4629
4630 if (ixj_WriteDSPCommand(arg, j))
4631 return -1;
4632
4633 return 0;
4634 }
4635
4636 static int SCI_WaitHighSCI(IXJ *j)
4637 {
4638 int cnt;
4639
4640 j->pld_scrr.byte = inb_p(j->XILINXbase);
4641 if (!j->pld_scrr.bits.sci) {
4642 for (cnt = 0; cnt < 10; cnt++) {
4643 udelay(32);
4644 j->pld_scrr.byte = inb_p(j->XILINXbase);
4645
4646 if ((j->pld_scrr.bits.sci))
4647 return 1;
4648 }
4649 if (ixjdebug & 0x0001)
4650 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4651 return 0;
4652 } else
4653 return 1;
4654 }
4655
4656 static int SCI_WaitLowSCI(IXJ *j)
4657 {
4658 int cnt;
4659
4660 j->pld_scrr.byte = inb_p(j->XILINXbase);
4661 if (j->pld_scrr.bits.sci) {
4662 for (cnt = 0; cnt < 10; cnt++) {
4663 udelay(32);
4664 j->pld_scrr.byte = inb_p(j->XILINXbase);
4665
4666 if (!(j->pld_scrr.bits.sci))
4667 return 1;
4668 }
4669 if (ixjdebug & 0x0001)
4670 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4671 return 0;
4672 } else
4673 return 1;
4674 }
4675
4676 static int SCI_Control(IXJ *j, int control)
4677 {
4678 switch (control) {
4679 case SCI_End:
4680 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4681
4682 j->pld_scrw.bits.c1 = 0; /* to no selection */
4683
4684 break;
4685 case SCI_Enable_DAA:
4686 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4687
4688 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4689
4690 break;
4691 case SCI_Enable_Mixer:
4692 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4693
4694 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4695
4696 break;
4697 case SCI_Enable_EEPROM:
4698 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4699
4700 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4701
4702 break;
4703 default:
4704 return 0;
4705 break;
4706 }
4707 outb_p(j->pld_scrw.byte, j->XILINXbase);
4708
4709 switch (control) {
4710 case SCI_End:
4711 return 1;
4712 break;
4713 case SCI_Enable_DAA:
4714 case SCI_Enable_Mixer:
4715 case SCI_Enable_EEPROM:
4716 if (!SCI_WaitHighSCI(j))
4717 return 0;
4718 break;
4719 default:
4720 return 0;
4721 break;
4722 }
4723 return 1;
4724 }
4725
4726 static int SCI_Prepare(IXJ *j)
4727 {
4728 if (!SCI_Control(j, SCI_End))
4729 return 0;
4730
4731 if (!SCI_WaitLowSCI(j))
4732 return 0;
4733
4734 return 1;
4735 }
4736
4737 static int ixj_get_mixer(long val, IXJ *j)
4738 {
4739 int reg = (val & 0x1F00) >> 8;
4740 return j->mix.vol[reg];
4741 }
4742
4743 static int ixj_mixer(long val, IXJ *j)
4744 {
4745 BYTES bytes;
4746
4747 bytes.high = (val & 0x1F00) >> 8;
4748 bytes.low = val & 0x00FF;
4749
4750 /* save mixer value so we can get back later on */
4751 j->mix.vol[bytes.high] = bytes.low;
4752
4753 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4754
4755 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4756
4757 SCI_Control(j, SCI_Enable_Mixer);
4758
4759 SCI_Control(j, SCI_End);
4760
4761 return 0;
4762 }
4763
4764 static int daa_load(BYTES * p_bytes, IXJ *j)
4765 {
4766 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4767 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4768 if (!SCI_Control(j, SCI_Enable_DAA))
4769 return 0;
4770 else
4771 return 1;
4772 }
4773
4774 static int ixj_daa_cr4(IXJ *j, char reg)
4775 {
4776 BYTES bytes;
4777
4778 switch (j->daa_mode) {
4779 case SOP_PU_SLEEP:
4780 bytes.high = 0x14;
4781 break;
4782 case SOP_PU_RINGING:
4783 bytes.high = 0x54;
4784 break;
4785 case SOP_PU_CONVERSATION:
4786 bytes.high = 0x94;
4787 break;
4788 case SOP_PU_PULSEDIALING:
4789 bytes.high = 0xD4;
4790 break;
4791 }
4792
4793 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4794
4795 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4796 case 0:
4797 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4798 break;
4799 case 1:
4800 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4801 break;
4802 case 2:
4803 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4804 break;
4805 case 3:
4806 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4807 break;
4808 }
4809
4810 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4811
4812 if (!daa_load(&bytes, j))
4813 return 0;
4814
4815 if (!SCI_Prepare(j))
4816 return 0;
4817
4818 return 1;
4819 }
4820
4821 static char daa_int_read(IXJ *j)
4822 {
4823 BYTES bytes;
4824
4825 if (!SCI_Prepare(j))
4826 return 0;
4827
4828 bytes.high = 0x38;
4829 bytes.low = 0x00;
4830 outb_p(bytes.high, j->XILINXbase + 0x03);
4831 outb_p(bytes.low, j->XILINXbase + 0x02);
4832
4833 if (!SCI_Control(j, SCI_Enable_DAA))
4834 return 0;
4835
4836 bytes.high = inb_p(j->XILINXbase + 0x03);
4837 bytes.low = inb_p(j->XILINXbase + 0x02);
4838 if (bytes.low != ALISDAA_ID_BYTE) {
4839 if (ixjdebug & 0x0001)
4840 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4841 return 0;
4842 }
4843 if (!SCI_Control(j, SCI_Enable_DAA))
4844 return 0;
4845 if (!SCI_Control(j, SCI_End))
4846 return 0;
4847
4848 bytes.high = inb_p(j->XILINXbase + 0x03);
4849 bytes.low = inb_p(j->XILINXbase + 0x02);
4850
4851 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4852
4853 return 1;
4854 }
4855
4856 static char daa_CR_read(IXJ *j, int cr)
4857 {
4858 IXJ_WORD wdata;
4859 BYTES bytes;
4860
4861 if (!SCI_Prepare(j))
4862 return 0;
4863
4864 switch (j->daa_mode) {
4865 case SOP_PU_SLEEP:
4866 bytes.high = 0x30 + cr;
4867 break;
4868 case SOP_PU_RINGING:
4869 bytes.high = 0x70 + cr;
4870 break;
4871 case SOP_PU_CONVERSATION:
4872 bytes.high = 0xB0 + cr;
4873 break;
4874 case SOP_PU_PULSEDIALING:
4875 default:
4876 bytes.high = 0xF0 + cr;
4877 break;
4878 }
4879
4880 bytes.low = 0x00;
4881
4882 outb_p(bytes.high, j->XILINXbase + 0x03);
4883 outb_p(bytes.low, j->XILINXbase + 0x02);
4884
4885 if (!SCI_Control(j, SCI_Enable_DAA))
4886 return 0;
4887
4888 bytes.high = inb_p(j->XILINXbase + 0x03);
4889 bytes.low = inb_p(j->XILINXbase + 0x02);
4890 if (bytes.low != ALISDAA_ID_BYTE) {
4891 if (ixjdebug & 0x0001)
4892 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4893 return 0;
4894 }
4895 if (!SCI_Control(j, SCI_Enable_DAA))
4896 return 0;
4897 if (!SCI_Control(j, SCI_End))
4898 return 0;
4899
4900 wdata.word = inw_p(j->XILINXbase + 0x02);
4901
4902 switch(cr){
4903 case 5:
4904 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4905 break;
4906 case 4:
4907 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4908 break;
4909 case 3:
4910 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4911 break;
4912 case 2:
4913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4914 break;
4915 case 1:
4916 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4917 break;
4918 case 0:
4919 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4920 break;
4921 default:
4922 return 0;
4923 }
4924 return 1;
4925 }
4926
4927 static int ixj_daa_cid_reset(IXJ *j)
4928 {
4929 int i;
4930 BYTES bytes;
4931
4932 if (ixjdebug & 0x0002)
4933 printk("DAA Clearing CID ram\n");
4934
4935 if (!SCI_Prepare(j))
4936 return 0;
4937
4938 bytes.high = 0x58;
4939 bytes.low = 0x00;
4940 outb_p(bytes.high, j->XILINXbase + 0x03);
4941 outb_p(bytes.low, j->XILINXbase + 0x02);
4942
4943 if (!SCI_Control(j, SCI_Enable_DAA))
4944 return 0;
4945
4946 if (!SCI_WaitHighSCI(j))
4947 return 0;
4948
4949 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4950 bytes.high = bytes.low = 0x00;
4951 outb_p(bytes.high, j->XILINXbase + 0x03);
4952
4953 if (i < ALISDAA_CALLERID_SIZE - 1)
4954 outb_p(bytes.low, j->XILINXbase + 0x02);
4955
4956 if (!SCI_Control(j, SCI_Enable_DAA))
4957 return 0;
4958
4959 if (!SCI_WaitHighSCI(j))
4960 return 0;
4961
4962 }
4963
4964 if (!SCI_Control(j, SCI_End))
4965 return 0;
4966
4967 if (ixjdebug & 0x0002)
4968 printk("DAA CID ram cleared\n");
4969
4970 return 1;
4971 }
4972
4973 static int ixj_daa_cid_read(IXJ *j)
4974 {
4975 int i;
4976 BYTES bytes;
4977 char CID[ALISDAA_CALLERID_SIZE];
4978 bool mContinue;
4979 char *pIn, *pOut;
4980
4981 if (!SCI_Prepare(j))
4982 return 0;
4983
4984 bytes.high = 0x78;
4985 bytes.low = 0x00;
4986 outb_p(bytes.high, j->XILINXbase + 0x03);
4987 outb_p(bytes.low, j->XILINXbase + 0x02);
4988
4989 if (!SCI_Control(j, SCI_Enable_DAA))
4990 return 0;
4991
4992 if (!SCI_WaitHighSCI(j))
4993 return 0;
4994
4995 bytes.high = inb_p(j->XILINXbase + 0x03);
4996 bytes.low = inb_p(j->XILINXbase + 0x02);
4997 if (bytes.low != ALISDAA_ID_BYTE) {
4998 if (ixjdebug & 0x0001)
4999 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5000 return 0;
5001 }
5002 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5003 bytes.high = bytes.low = 0x00;
5004 outb_p(bytes.high, j->XILINXbase + 0x03);
5005 outb_p(bytes.low, j->XILINXbase + 0x02);
5006
5007 if (!SCI_Control(j, SCI_Enable_DAA))
5008 return 0;
5009
5010 if (!SCI_WaitHighSCI(j))
5011 return 0;
5012
5013 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5014 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5015 }
5016
5017 if (!SCI_Control(j, SCI_End))
5018 return 0;
5019
5020 pIn = CID;
5021 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5022 mContinue = true;
5023 while (mContinue) {
5024 if ((pIn[1] & 0x03) == 0x01) {
5025 pOut[0] = pIn[0];
5026 }
5027 if ((pIn[2] & 0x0c) == 0x04) {
5028 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5029 }
5030 if ((pIn[3] & 0x30) == 0x10) {
5031 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5032 }
5033 if ((pIn[4] & 0xc0) == 0x40) {
5034 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5035 } else {
5036 mContinue = false;
5037 }
5038 pIn += 5, pOut += 4;
5039 }
5040 memset(&j->cid, 0, sizeof(PHONE_CID));
5041 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5042 pOut += 4;
5043 strncpy(j->cid.month, pOut, 2);
5044 pOut += 2;
5045 strncpy(j->cid.day, pOut, 2);
5046 pOut += 2;
5047 strncpy(j->cid.hour, pOut, 2);
5048 pOut += 2;
5049 strncpy(j->cid.min, pOut, 2);
5050 pOut += 3;
5051 j->cid.numlen = *pOut;
5052 pOut += 1;
5053 strncpy(j->cid.number, pOut, j->cid.numlen);
5054 pOut += j->cid.numlen + 1;
5055 j->cid.namelen = *pOut;
5056 pOut += 1;
5057 strncpy(j->cid.name, pOut, j->cid.namelen);
5058
5059 ixj_daa_cid_reset(j);
5060 return 1;
5061 }
5062
5063 static char daa_get_version(IXJ *j)
5064 {
5065 BYTES bytes;
5066
5067 if (!SCI_Prepare(j))
5068 return 0;
5069
5070 bytes.high = 0x35;
5071 bytes.low = 0x00;
5072 outb_p(bytes.high, j->XILINXbase + 0x03);
5073 outb_p(bytes.low, j->XILINXbase + 0x02);
5074
5075 if (!SCI_Control(j, SCI_Enable_DAA))
5076 return 0;
5077
5078 bytes.high = inb_p(j->XILINXbase + 0x03);
5079 bytes.low = inb_p(j->XILINXbase + 0x02);
5080 if (bytes.low != ALISDAA_ID_BYTE) {
5081 if (ixjdebug & 0x0001)
5082 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5083 return 0;
5084 }
5085 if (!SCI_Control(j, SCI_Enable_DAA))
5086 return 0;
5087
5088 if (!SCI_Control(j, SCI_End))
5089 return 0;
5090
5091 bytes.high = inb_p(j->XILINXbase + 0x03);
5092 bytes.low = inb_p(j->XILINXbase + 0x02);
5093 if (ixjdebug & 0x0002)
5094 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5095 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5096 return bytes.high;
5097 }
5098
5099 static int daa_set_mode(IXJ *j, int mode)
5100 {
5101 /* NOTE:
5102 The DAA *MUST* be in the conversation mode if the
5103 PSTN line is to be seized (PSTN line off-hook).
5104 Taking the PSTN line off-hook while the DAA is in
5105 a mode other than conversation mode will cause a
5106 hardware failure of the ALIS-A part.
5107
5108 NOTE:
5109 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5110 if the PSTN line is on-hook. Failure to have the PSTN line
5111 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5112 ALIS-A part.
5113 */
5114
5115 BYTES bytes;
5116
5117 j->flags.pstn_rmr = 0;
5118
5119 if (!SCI_Prepare(j))
5120 return 0;
5121
5122 switch (mode) {
5123 case SOP_PU_RESET:
5124 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5125
5126 outb_p(j->pld_scrw.byte, j->XILINXbase);
5127 j->pld_slicw.bits.rly2 = 0;
5128 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5129 bytes.high = 0x10;
5130 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5131 daa_load(&bytes, j);
5132 if (!SCI_Prepare(j))
5133 return 0;
5134
5135 j->daa_mode = SOP_PU_SLEEP;
5136 break;
5137 case SOP_PU_SLEEP:
5138 if(j->daa_mode == SOP_PU_SLEEP)
5139 {
5140 break;
5141 }
5142 if (ixjdebug & 0x0008)
5143 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5144 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5145 {
5146 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5147
5148 outb_p(j->pld_scrw.byte, j->XILINXbase);
5149 j->pld_slicw.bits.rly2 = 0;
5150 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5151 bytes.high = 0x10;
5152 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5153 daa_load(&bytes, j);
5154 if (!SCI_Prepare(j))
5155 return 0;
5156 }
5157 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5158
5159 outb_p(j->pld_scrw.byte, j->XILINXbase);
5160 j->pld_slicw.bits.rly2 = 0;
5161 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5162 bytes.high = 0x10;
5163 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5164 daa_load(&bytes, j);
5165 if (!SCI_Prepare(j))
5166 return 0;
5167
5168 j->daa_mode = SOP_PU_SLEEP;
5169 j->flags.pstn_ringing = 0;
5170 j->ex.bits.pstn_ring = 0;
5171 j->pstn_sleeptil = jiffies + (hertz / 4);
5172 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5173 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5174 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5175 break;
5176 case SOP_PU_RINGING:
5177 if (ixjdebug & 0x0008)
5178 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5179 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5180
5181 outb_p(j->pld_scrw.byte, j->XILINXbase);
5182 j->pld_slicw.bits.rly2 = 0;
5183 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5184 bytes.high = 0x50;
5185 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5186 daa_load(&bytes, j);
5187 if (!SCI_Prepare(j))
5188 return 0;
5189 j->daa_mode = SOP_PU_RINGING;
5190 break;
5191 case SOP_PU_CONVERSATION:
5192 if (ixjdebug & 0x0008)
5193 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5194 bytes.high = 0x90;
5195 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5196 daa_load(&bytes, j);
5197 if (!SCI_Prepare(j))
5198 return 0;
5199 j->pld_slicw.bits.rly2 = 1;
5200 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5201 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5202
5203 outb_p(j->pld_scrw.byte, j->XILINXbase);
5204 j->daa_mode = SOP_PU_CONVERSATION;
5205 j->flags.pstn_ringing = 0;
5206 j->ex.bits.pstn_ring = 0;
5207 j->pstn_sleeptil = jiffies;
5208 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5209 break;
5210 case SOP_PU_PULSEDIALING:
5211 if (ixjdebug & 0x0008)
5212 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5213 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5214
5215 outb_p(j->pld_scrw.byte, j->XILINXbase);
5216 j->pld_slicw.bits.rly2 = 0;
5217 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5218 bytes.high = 0xD0;
5219 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5220 daa_load(&bytes, j);
5221 if (!SCI_Prepare(j))
5222 return 0;
5223 j->daa_mode = SOP_PU_PULSEDIALING;
5224 break;
5225 default:
5226 break;
5227 }
5228 return 1;
5229 }
5230
5231 static int ixj_daa_write(IXJ *j)
5232 {
5233 BYTES bytes;
5234
5235 j->flags.pstncheck = 1;
5236
5237 daa_set_mode(j, SOP_PU_SLEEP);
5238
5239 if (!SCI_Prepare(j))
5240 return 0;
5241
5242 outb_p(j->pld_scrw.byte, j->XILINXbase);
5243
5244 bytes.high = 0x14;
5245 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5246 if (!daa_load(&bytes, j))
5247 return 0;
5248
5249 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5250 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5251 if (!daa_load(&bytes, j))
5252 return 0;
5253
5254 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5255 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5256 if (!daa_load(&bytes, j))
5257 return 0;
5258
5259 if (!SCI_Prepare(j))
5260 return 0;
5261
5262 bytes.high = 0x1F;
5263 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5264 if (!daa_load(&bytes, j))
5265 return 0;
5266
5267 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5268 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5269 if (!daa_load(&bytes, j))
5270 return 0;
5271
5272 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5273 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5274 if (!daa_load(&bytes, j))
5275 return 0;
5276
5277 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5278 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5279 if (!daa_load(&bytes, j))
5280 return 0;
5281
5282 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5283 bytes.low = 0x00;
5284 if (!daa_load(&bytes, j))
5285 return 0;
5286
5287 if (!SCI_Prepare(j))
5288 return 0;
5289
5290 bytes.high = 0x00;
5291 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5292 if (!daa_load(&bytes, j))
5293 return 0;
5294
5295 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5296 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5297 if (!daa_load(&bytes, j))
5298 return 0;
5299
5300 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5301 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5302 if (!daa_load(&bytes, j))
5303 return 0;
5304
5305 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5306 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5307 if (!daa_load(&bytes, j))
5308 return 0;
5309
5310 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5311 bytes.low = 0x00;
5312 if (!daa_load(&bytes, j))
5313 return 0;
5314
5315 if (!SCI_Control(j, SCI_End))
5316 return 0;
5317 if (!SCI_WaitLowSCI(j))
5318 return 0;
5319
5320 bytes.high = 0x01;
5321 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5322 if (!daa_load(&bytes, j))
5323 return 0;
5324
5325 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5326 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5327 if (!daa_load(&bytes, j))
5328 return 0;
5329
5330 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5331 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5332 if (!daa_load(&bytes, j))
5333 return 0;
5334
5335 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5336 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5337 if (!daa_load(&bytes, j))
5338 return 0;
5339
5340 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5341 bytes.low = 0x00;
5342 if (!daa_load(&bytes, j))
5343 return 0;
5344
5345 if (!SCI_Control(j, SCI_End))
5346 return 0;
5347 if (!SCI_WaitLowSCI(j))
5348 return 0;
5349
5350 bytes.high = 0x02;
5351 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5352 if (!daa_load(&bytes, j))
5353 return 0;
5354
5355 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5356 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5357 if (!daa_load(&bytes, j))
5358 return 0;
5359
5360 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5361 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5362 if (!daa_load(&bytes, j))
5363 return 0;
5364
5365 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5366 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5367 if (!daa_load(&bytes, j))
5368 return 0;
5369
5370 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5371 bytes.low = 0x00;
5372 if (!daa_load(&bytes, j))
5373 return 0;
5374
5375 if (!SCI_Control(j, SCI_End))
5376 return 0;
5377 if (!SCI_WaitLowSCI(j))
5378 return 0;
5379
5380 bytes.high = 0x03;
5381 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5382 if (!daa_load(&bytes, j))
5383 return 0;
5384
5385 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5386 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5387 if (!daa_load(&bytes, j))
5388 return 0;
5389
5390 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5391 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5392 if (!daa_load(&bytes, j))
5393 return 0;
5394
5395 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5396 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5397 if (!daa_load(&bytes, j))
5398 return 0;
5399
5400 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5401 bytes.low = 0x00;
5402 if (!daa_load(&bytes, j))
5403 return 0;
5404
5405 if (!SCI_Control(j, SCI_End))
5406 return 0;
5407 if (!SCI_WaitLowSCI(j))
5408 return 0;
5409
5410 bytes.high = 0x04;
5411 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5412 if (!daa_load(&bytes, j))
5413 return 0;
5414
5415 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5416 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5417 if (!daa_load(&bytes, j))
5418 return 0;
5419
5420 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5421 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5422 if (!daa_load(&bytes, j))
5423 return 0;
5424
5425 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5426 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5427 if (!daa_load(&bytes, j))
5428 return 0;
5429
5430 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5431 bytes.low = 0x00;
5432 if (!daa_load(&bytes, j))
5433 return 0;
5434
5435 if (!SCI_Control(j, SCI_End))
5436 return 0;
5437 if (!SCI_WaitLowSCI(j))
5438 return 0;
5439
5440 bytes.high = 0x05;
5441 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5442 if (!daa_load(&bytes, j))
5443 return 0;
5444
5445 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5446 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5447 if (!daa_load(&bytes, j))
5448 return 0;
5449
5450 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5451 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5452 if (!daa_load(&bytes, j))
5453 return 0;
5454
5455 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5456 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5457 if (!daa_load(&bytes, j))
5458 return 0;
5459
5460 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5461 bytes.low = 0x00;
5462 if (!daa_load(&bytes, j))
5463 return 0;
5464
5465 if (!SCI_Control(j, SCI_End))
5466 return 0;
5467 if (!SCI_WaitLowSCI(j))
5468 return 0;
5469
5470 bytes.high = 0x06;
5471 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5472 if (!daa_load(&bytes, j))
5473 return 0;
5474
5475 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5476 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5477 if (!daa_load(&bytes, j))
5478 return 0;
5479
5480 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5481 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5482 if (!daa_load(&bytes, j))
5483 return 0;
5484
5485 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5486 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5487 if (!daa_load(&bytes, j))
5488 return 0;
5489
5490 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5491 bytes.low = 0x00;
5492 if (!daa_load(&bytes, j))
5493 return 0;
5494
5495 if (!SCI_Control(j, SCI_End))
5496 return 0;
5497 if (!SCI_WaitLowSCI(j))
5498 return 0;
5499
5500 bytes.high = 0x07;
5501 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5502 if (!daa_load(&bytes, j))
5503 return 0;
5504
5505 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5506 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5507 if (!daa_load(&bytes, j))
5508 return 0;
5509
5510 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5511 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5512 if (!daa_load(&bytes, j))
5513 return 0;
5514
5515 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5516 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5517 if (!daa_load(&bytes, j))
5518 return 0;
5519
5520 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5521 bytes.low = 0x00;
5522 if (!daa_load(&bytes, j))
5523 return 0;
5524
5525 if (!SCI_Control(j, SCI_End))
5526 return 0;
5527 if (!SCI_WaitLowSCI(j))
5528 return 0;
5529
5530 bytes.high = 0x08;
5531 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5532 if (!daa_load(&bytes, j))
5533 return 0;
5534
5535 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5536 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5537 if (!daa_load(&bytes, j))
5538 return 0;
5539
5540 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5541 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5542 if (!daa_load(&bytes, j))
5543 return 0;
5544
5545 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5546 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5547 if (!daa_load(&bytes, j))
5548 return 0;
5549
5550 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5551 bytes.low = 0x00;
5552 if (!daa_load(&bytes, j))
5553 return 0;
5554
5555 if (!SCI_Control(j, SCI_End))
5556 return 0;
5557 if (!SCI_WaitLowSCI(j))
5558 return 0;
5559
5560 bytes.high = 0x09;
5561 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5562 if (!daa_load(&bytes, j))
5563 return 0;
5564
5565 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5566 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5567 if (!daa_load(&bytes, j))
5568 return 0;
5569
5570 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5571 bytes.low = 0x00;
5572 if (!daa_load(&bytes, j))
5573 return 0;
5574
5575 if (!SCI_Control(j, SCI_End))
5576 return 0;
5577 if (!SCI_WaitLowSCI(j))
5578 return 0;
5579
5580 bytes.high = 0x0A;
5581 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5582 if (!daa_load(&bytes, j))
5583 return 0;
5584
5585 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5586 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5587 if (!daa_load(&bytes, j))
5588 return 0;
5589
5590 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5591 bytes.low = 0x00;
5592 if (!daa_load(&bytes, j))
5593 return 0;
5594
5595 if (!SCI_Control(j, SCI_End))
5596 return 0;
5597 if (!SCI_WaitLowSCI(j))
5598 return 0;
5599
5600 bytes.high = 0x0B;
5601 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5602 if (!daa_load(&bytes, j))
5603 return 0;
5604
5605 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5606 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5607 if (!daa_load(&bytes, j))
5608 return 0;
5609
5610 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5611 bytes.low = 0x00;
5612 if (!daa_load(&bytes, j))
5613 return 0;
5614
5615 if (!SCI_Control(j, SCI_End))
5616 return 0;
5617 if (!SCI_WaitLowSCI(j))
5618 return 0;
5619
5620 bytes.high = 0x0C;
5621 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5622 if (!daa_load(&bytes, j))
5623 return 0;
5624
5625 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5626 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5627 if (!daa_load(&bytes, j))
5628 return 0;
5629
5630 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5631 bytes.low = 0x00;
5632 if (!daa_load(&bytes, j))
5633 return 0;
5634
5635 if (!SCI_Control(j, SCI_End))
5636 return 0;
5637 if (!SCI_WaitLowSCI(j))
5638 return 0;
5639
5640 bytes.high = 0x0D;
5641 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5642 if (!daa_load(&bytes, j))
5643 return 0;
5644
5645 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5646 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5647 if (!daa_load(&bytes, j))
5648 return 0;
5649
5650 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5651 bytes.low = 0x00;
5652 if (!daa_load(&bytes, j))
5653 return 0;
5654
5655 if (!SCI_Control(j, SCI_End))
5656 return 0;
5657 if (!SCI_WaitLowSCI(j))
5658 return 0;
5659
5660 bytes.high = 0x0E;
5661 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5662 if (!daa_load(&bytes, j))
5663 return 0;
5664
5665 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5666 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5667 if (!daa_load(&bytes, j))
5668 return 0;
5669
5670 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5671 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5672 if (!daa_load(&bytes, j))
5673 return 0;
5674
5675 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5676 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5677 if (!daa_load(&bytes, j))
5678 return 0;
5679
5680 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5681 bytes.low = 0x00;
5682 if (!daa_load(&bytes, j))
5683 return 0;
5684
5685 if (!SCI_Control(j, SCI_End))
5686 return 0;
5687 if (!SCI_WaitLowSCI(j))
5688 return 0;
5689
5690 bytes.high = 0x0F;
5691 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5692 if (!daa_load(&bytes, j))
5693 return 0;
5694
5695 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5696 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5697 if (!daa_load(&bytes, j))
5698 return 0;
5699
5700 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5701 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5702 if (!daa_load(&bytes, j))
5703 return 0;
5704
5705 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5706 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5707 if (!daa_load(&bytes, j))
5708 return 0;
5709
5710 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5711 bytes.low = 0x00;
5712 if (!daa_load(&bytes, j))
5713 return 0;
5714
5715 udelay(32);
5716 j->pld_scrr.byte = inb_p(j->XILINXbase);
5717 if (!SCI_Control(j, SCI_End))
5718 return 0;
5719
5720 outb_p(j->pld_scrw.byte, j->XILINXbase);
5721
5722 if (ixjdebug & 0x0002)
5723 printk("DAA Coefficients Loaded\n");
5724
5725 j->flags.pstncheck = 0;
5726 return 1;
5727 }
5728
5729 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5730 {
5731 j->tone_off_time = arg;
5732 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5733
5734 return -1;
5735 if (ixj_WriteDSPCommand(arg, j))
5736 return -1;
5737 return 0;
5738 }
5739
5740 static int ixj_get_tone_on(IXJ *j)
5741 {
5742 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5743
5744 return -1;
5745 return 0;
5746 }
5747
5748 static int ixj_get_tone_off(IXJ *j)
5749 {
5750 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5751
5752 return -1;
5753 return 0;
5754 }
5755
5756 static void ixj_busytone(IXJ *j)
5757 {
5758 j->flags.ringback = 0;
5759 j->flags.dialtone = 0;
5760 j->flags.busytone = 1;
5761 ixj_set_tone_on(0x07D0, j);
5762 ixj_set_tone_off(0x07D0, j);
5763 ixj_play_tone(j, 27);
5764 }
5765
5766 static void ixj_dialtone(IXJ *j)
5767 {
5768 j->flags.ringback = 0;
5769 j->flags.dialtone = 1;
5770 j->flags.busytone = 0;
5771 if (j->dsp.low == 0x20) {
5772 return;
5773 } else {
5774 ixj_set_tone_on(0xFFFF, j);
5775 ixj_set_tone_off(0x0000, j);
5776 ixj_play_tone(j, 25);
5777 }
5778 }
5779
5780 static void ixj_cpt_stop(IXJ *j)
5781 {
5782 if(j->tone_state || j->tone_cadence_state)
5783 {
5784 j->flags.dialtone = 0;
5785 j->flags.busytone = 0;
5786 j->flags.ringback = 0;
5787 ixj_set_tone_on(0x0001, j);
5788 ixj_set_tone_off(0x0000, j);
5789 ixj_play_tone(j, 0);
5790 j->tone_state = j->tone_cadence_state = 0;
5791 if (j->cadence_t) {
5792 kfree(j->cadence_t->ce);
5793 kfree(j->cadence_t);
5794 j->cadence_t = NULL;
5795 }
5796 }
5797 if (j->play_mode == -1 && j->rec_mode == -1)
5798 idle(j);
5799 if (j->play_mode != -1 && j->dsp.low == 0x20)
5800 ixj_play_start(j);
5801 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5802 ixj_record_start(j);
5803 }
5804
5805 static void ixj_ringback(IXJ *j)
5806 {
5807 j->flags.busytone = 0;
5808 j->flags.dialtone = 0;
5809 j->flags.ringback = 1;
5810 ixj_set_tone_on(0x0FA0, j);
5811 ixj_set_tone_off(0x2EE0, j);
5812 ixj_play_tone(j, 26);
5813 }
5814
5815 static void ixj_testram(IXJ *j)
5816 {
5817 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5818 }
5819
5820 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5821 {
5822 ixj_cadence *lcp;
5823 IXJ_CADENCE_ELEMENT __user *cep;
5824 IXJ_CADENCE_ELEMENT *lcep;
5825 IXJ_TONE ti;
5826 int err;
5827
5828 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5829 if (lcp == NULL)
5830 return -ENOMEM;
5831
5832 err = -EFAULT;
5833 if (copy_from_user(&lcp->elements_used,
5834 &cp->elements_used, sizeof(int)))
5835 goto out;
5836 if (copy_from_user(&lcp->termination,
5837 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5838 goto out;
5839 if (get_user(cep, &cp->ce))
5840 goto out;
5841
5842 err = -EINVAL;
5843 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5844 goto out;
5845
5846 err = -ENOMEM;
5847 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5848 if (!lcep)
5849 goto out;
5850
5851 err = -EFAULT;
5852 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5853 goto out1;
5854
5855 if (j->cadence_t) {
5856 kfree(j->cadence_t->ce);
5857 kfree(j->cadence_t);
5858 }
5859 lcp->ce = (void *) lcep;
5860 j->cadence_t = lcp;
5861 j->tone_cadence_state = 0;
5862 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5863 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5864 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5865 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5866 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5867 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5868 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5869 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5870 ixj_init_tone(j, &ti);
5871 }
5872 ixj_play_tone(j, lcp->ce[0].index);
5873 return 1;
5874 out1:
5875 kfree(lcep);
5876 out:
5877 kfree(lcp);
5878 return err;
5879 }
5880
5881 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5882 {
5883 IXJ_FILTER_CADENCE *lcp;
5884 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5885 if (lcp == NULL) {
5886 if(ixjdebug & 0x0001) {
5887 printk(KERN_INFO "Could not allocate memory for cadence\n");
5888 }
5889 return -ENOMEM;
5890 }
5891 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5892 if(ixjdebug & 0x0001) {
5893 printk(KERN_INFO "Could not copy cadence to kernel\n");
5894 }
5895 kfree(lcp);
5896 return -EFAULT;
5897 }
5898 if (lcp->filter > 5) {
5899 if(ixjdebug & 0x0001) {
5900 printk(KERN_INFO "Cadence out of range\n");
5901 }
5902 kfree(lcp);
5903 return -1;
5904 }
5905 j->cadence_f[lcp->filter].state = 0;
5906 j->cadence_f[lcp->filter].enable = lcp->enable;
5907 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5908 j->cadence_f[lcp->filter].on1 = lcp->on1;
5909 j->cadence_f[lcp->filter].on1min = 0;
5910 j->cadence_f[lcp->filter].on1max = 0;
5911 j->cadence_f[lcp->filter].off1 = lcp->off1;
5912 j->cadence_f[lcp->filter].off1min = 0;
5913 j->cadence_f[lcp->filter].off1max = 0;
5914 j->cadence_f[lcp->filter].on2 = lcp->on2;
5915 j->cadence_f[lcp->filter].on2min = 0;
5916 j->cadence_f[lcp->filter].on2max = 0;
5917 j->cadence_f[lcp->filter].off2 = lcp->off2;
5918 j->cadence_f[lcp->filter].off2min = 0;
5919 j->cadence_f[lcp->filter].off2max = 0;
5920 j->cadence_f[lcp->filter].on3 = lcp->on3;
5921 j->cadence_f[lcp->filter].on3min = 0;
5922 j->cadence_f[lcp->filter].on3max = 0;
5923 j->cadence_f[lcp->filter].off3 = lcp->off3;
5924 j->cadence_f[lcp->filter].off3min = 0;
5925 j->cadence_f[lcp->filter].off3max = 0;
5926 if(ixjdebug & 0x0002) {
5927 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5928 }
5929 kfree(lcp);
5930 return 0;
5931 }
5932
5933 static void add_caps(IXJ *j)
5934 {
5935 j->caps = 0;
5936 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5937 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5938 j->caplist[j->caps].captype = vendor;
5939 j->caplist[j->caps].handle = j->caps++;
5940 j->caplist[j->caps].captype = device;
5941 switch (j->cardtype) {
5942 case QTI_PHONEJACK:
5943 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5944 break;
5945 case QTI_LINEJACK:
5946 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5947 break;
5948 case QTI_PHONEJACK_LITE:
5949 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5950 break;
5951 case QTI_PHONEJACK_PCI:
5952 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5953 break;
5954 case QTI_PHONECARD:
5955 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5956 break;
5957 }
5958 j->caplist[j->caps].cap = j->cardtype;
5959 j->caplist[j->caps].handle = j->caps++;
5960 strcpy(j->caplist[j->caps].desc, "POTS");
5961 j->caplist[j->caps].captype = port;
5962 j->caplist[j->caps].cap = pots;
5963 j->caplist[j->caps].handle = j->caps++;
5964
5965 /* add devices that can do speaker/mic */
5966 switch (j->cardtype) {
5967 case QTI_PHONEJACK:
5968 case QTI_LINEJACK:
5969 case QTI_PHONEJACK_PCI:
5970 case QTI_PHONECARD:
5971 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5972 j->caplist[j->caps].captype = port;
5973 j->caplist[j->caps].cap = speaker;
5974 j->caplist[j->caps].handle = j->caps++;
5975 default:
5976 break;
5977 }
5978
5979 /* add devices that can do handset */
5980 switch (j->cardtype) {
5981 case QTI_PHONEJACK:
5982 strcpy(j->caplist[j->caps].desc, "HANDSET");
5983 j->caplist[j->caps].captype = port;
5984 j->caplist[j->caps].cap = handset;
5985 j->caplist[j->caps].handle = j->caps++;
5986 break;
5987 default:
5988 break;
5989 }
5990
5991 /* add devices that can do PSTN */
5992 switch (j->cardtype) {
5993 case QTI_LINEJACK:
5994 strcpy(j->caplist[j->caps].desc, "PSTN");
5995 j->caplist[j->caps].captype = port;
5996 j->caplist[j->caps].cap = pstn;
5997 j->caplist[j->caps].handle = j->caps++;
5998 break;
5999 default:
6000 break;
6001 }
6002
6003 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6004 strcpy(j->caplist[j->caps].desc, "ULAW");
6005 j->caplist[j->caps].captype = codec;
6006 j->caplist[j->caps].cap = ULAW;
6007 j->caplist[j->caps].handle = j->caps++;
6008
6009 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6010 j->caplist[j->caps].captype = codec;
6011 j->caplist[j->caps].cap = LINEAR16;
6012 j->caplist[j->caps].handle = j->caps++;
6013
6014 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6015 j->caplist[j->caps].captype = codec;
6016 j->caplist[j->caps].cap = LINEAR8;
6017 j->caplist[j->caps].handle = j->caps++;
6018
6019 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6020 j->caplist[j->caps].captype = codec;
6021 j->caplist[j->caps].cap = WSS;
6022 j->caplist[j->caps].handle = j->caps++;
6023
6024 /* software ALAW codec, made from ULAW */
6025 strcpy(j->caplist[j->caps].desc, "ALAW");
6026 j->caplist[j->caps].captype = codec;
6027 j->caplist[j->caps].cap = ALAW;
6028 j->caplist[j->caps].handle = j->caps++;
6029
6030 /* version 12 of the 8020 does the following codecs in a broken way */
6031 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6032 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6033 j->caplist[j->caps].captype = codec;
6034 j->caplist[j->caps].cap = G723_63;
6035 j->caplist[j->caps].handle = j->caps++;
6036
6037 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6038 j->caplist[j->caps].captype = codec;
6039 j->caplist[j->caps].cap = G723_53;
6040 j->caplist[j->caps].handle = j->caps++;
6041
6042 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6043 j->caplist[j->caps].captype = codec;
6044 j->caplist[j->caps].cap = TS48;
6045 j->caplist[j->caps].handle = j->caps++;
6046
6047 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6048 j->caplist[j->caps].captype = codec;
6049 j->caplist[j->caps].cap = TS41;
6050 j->caplist[j->caps].handle = j->caps++;
6051 }
6052
6053 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6054 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6055 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6056 j->caplist[j->caps].captype = codec;
6057 j->caplist[j->caps].cap = TS85;
6058 j->caplist[j->caps].handle = j->caps++;
6059 }
6060
6061 /* 8021 chips can do G728 */
6062 if (j->dsp.low == 0x21) {
6063 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6064 j->caplist[j->caps].captype = codec;
6065 j->caplist[j->caps].cap = G728;
6066 j->caplist[j->caps].handle = j->caps++;
6067 }
6068
6069 /* 8021/8022 chips can do G729 if loaded */
6070 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6071 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6072 j->caplist[j->caps].captype = codec;
6073 j->caplist[j->caps].cap = G729;
6074 j->caplist[j->caps].handle = j->caps++;
6075 }
6076 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6077 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6078 j->caplist[j->caps].captype = codec;
6079 j->caplist[j->caps].cap = G729B;
6080 j->caplist[j->caps].handle = j->caps++;
6081 }
6082 }
6083
6084 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6085 {
6086 int cnt;
6087 int retval = 0;
6088 for (cnt = 0; cnt < j->caps; cnt++) {
6089 if (pcreq->captype == j->caplist[cnt].captype
6090 && pcreq->cap == j->caplist[cnt].cap) {
6091 retval = 1;
6092 break;
6093 }
6094 }
6095 return retval;
6096 }
6097
6098 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6099 {
6100 IXJ_TONE ti;
6101 IXJ_FILTER jf;
6102 IXJ_FILTER_RAW jfr;
6103 void __user *argp = (void __user *)arg;
6104 struct inode *inode = file_p->f_path.dentry->d_inode;
6105 unsigned int minor = iminor(inode);
6106 unsigned int raise, mant;
6107 int board = NUM(inode);
6108
6109 IXJ *j = get_ixj(NUM(inode));
6110
6111 int retval = 0;
6112
6113 /*
6114 * Set up locks to ensure that only one process is talking to the DSP at a time.
6115 * This is necessary to keep the DSP from locking up.
6116 */
6117 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6118 schedule_timeout_interruptible(1);
6119 if (ixjdebug & 0x0040)
6120 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6121 if (minor >= IXJMAX) {
6122 clear_bit(board, &j->busyflags);
6123 return -ENODEV;
6124 }
6125 /*
6126 * Check ioctls only root can use.
6127 */
6128 if (!capable(CAP_SYS_ADMIN)) {
6129 switch (cmd) {
6130 case IXJCTL_TESTRAM:
6131 case IXJCTL_HZ:
6132 retval = -EPERM;
6133 }
6134 }
6135 switch (cmd) {
6136 case IXJCTL_TESTRAM:
6137 ixj_testram(j);
6138 retval = (j->ssr.high << 8) + j->ssr.low;
6139 break;
6140 case IXJCTL_CARDTYPE:
6141 retval = j->cardtype;
6142 break;
6143 case IXJCTL_SERIAL:
6144 retval = j->serial;
6145 break;
6146 case IXJCTL_VERSION:
6147 {
6148 char arg_str[100];
6149 snprintf(arg_str, sizeof(arg_str),
6150 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6151 IXJ_VER_MINOR, IXJ_BLD_VER);
6152 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6153 retval = -EFAULT;
6154 }
6155 break;
6156 case PHONE_RING_CADENCE:
6157 j->ring_cadence = arg;
6158 break;
6159 case IXJCTL_CIDCW:
6160 if(arg) {
6161 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6162 retval = -EFAULT;
6163 break;
6164 }
6165 } else {
6166 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6167 }
6168 ixj_write_cidcw(j);
6169 break;
6170 /* Binary compatbility */
6171 case OLD_PHONE_RING_START:
6172 arg = 0;
6173 /* Fall through */
6174 case PHONE_RING_START:
6175 if(arg) {
6176 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6177 retval = -EFAULT;
6178 break;
6179 }
6180 ixj_write_cid(j);
6181 } else {
6182 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6183 }
6184 ixj_ring_start(j);
6185 break;
6186 case PHONE_RING_STOP:
6187 j->flags.cringing = 0;
6188 if(j->cadence_f[5].enable) {
6189 j->cadence_f[5].state = 0;
6190 }
6191 ixj_ring_off(j);
6192 break;
6193 case PHONE_RING:
6194 retval = ixj_ring(j);
6195 break;
6196 case PHONE_EXCEPTION:
6197 retval = j->ex.bytes;
6198 if(j->ex.bits.flash) {
6199 j->flash_end = 0;
6200 j->ex.bits.flash = 0;
6201 }
6202 j->ex.bits.pstn_ring = 0;
6203 j->ex.bits.caller_id = 0;
6204 j->ex.bits.pstn_wink = 0;
6205 j->ex.bits.f0 = 0;
6206 j->ex.bits.f1 = 0;
6207 j->ex.bits.f2 = 0;
6208 j->ex.bits.f3 = 0;
6209 j->ex.bits.fc0 = 0;
6210 j->ex.bits.fc1 = 0;
6211 j->ex.bits.fc2 = 0;
6212 j->ex.bits.fc3 = 0;
6213 j->ex.bits.reserved = 0;
6214 break;
6215 case PHONE_HOOKSTATE:
6216 j->ex.bits.hookstate = 0;
6217 retval = j->hookstate; //j->r_hook;
6218 break;
6219 case IXJCTL_SET_LED:
6220 LED_SetState(arg, j);
6221 break;
6222 case PHONE_FRAME:
6223 retval = set_base_frame(j, arg);
6224 break;
6225 case PHONE_REC_CODEC:
6226 retval = set_rec_codec(j, arg);
6227 break;
6228 case PHONE_VAD:
6229 ixj_vad(j, arg);
6230 break;
6231 case PHONE_REC_START:
6232 ixj_record_start(j);
6233 break;
6234 case PHONE_REC_STOP:
6235 ixj_record_stop(j);
6236 break;
6237 case PHONE_REC_DEPTH:
6238 set_rec_depth(j, arg);
6239 break;
6240 case PHONE_REC_VOLUME:
6241 if(arg == -1) {
6242 retval = get_rec_volume(j);
6243 }
6244 else {
6245 set_rec_volume(j, arg);
6246 retval = arg;
6247 }
6248 break;
6249 case PHONE_REC_VOLUME_LINEAR:
6250 if(arg == -1) {
6251 retval = get_rec_volume_linear(j);
6252 }
6253 else {
6254 set_rec_volume_linear(j, arg);
6255 retval = arg;
6256 }
6257 break;
6258 case IXJCTL_DTMF_PRESCALE:
6259 if(arg == -1) {
6260 retval = get_dtmf_prescale(j);
6261 }
6262 else {
6263 set_dtmf_prescale(j, arg);
6264 retval = arg;
6265 }
6266 break;
6267 case PHONE_REC_LEVEL:
6268 retval = get_rec_level(j);
6269 break;
6270 case IXJCTL_SC_RXG:
6271 retval = ixj_siadc(j, arg);
6272 break;
6273 case IXJCTL_SC_TXG:
6274 retval = ixj_sidac(j, arg);
6275 break;
6276 case IXJCTL_AEC_START:
6277 ixj_aec_start(j, arg);
6278 break;
6279 case IXJCTL_AEC_STOP:
6280 aec_stop(j);
6281 break;
6282 case IXJCTL_AEC_GET_LEVEL:
6283 retval = j->aec_level;
6284 break;
6285 case PHONE_PLAY_CODEC:
6286 retval = set_play_codec(j, arg);
6287 break;
6288 case PHONE_PLAY_START:
6289 retval = ixj_play_start(j);
6290 break;
6291 case PHONE_PLAY_STOP:
6292 ixj_play_stop(j);
6293 break;
6294 case PHONE_PLAY_DEPTH:
6295 set_play_depth(j, arg);
6296 break;
6297 case PHONE_PLAY_VOLUME:
6298 if(arg == -1) {
6299 retval = get_play_volume(j);
6300 }
6301 else {
6302 set_play_volume(j, arg);
6303 retval = arg;
6304 }
6305 break;
6306 case PHONE_PLAY_VOLUME_LINEAR:
6307 if(arg == -1) {
6308 retval = get_play_volume_linear(j);
6309 }
6310 else {
6311 set_play_volume_linear(j, arg);
6312 retval = arg;
6313 }
6314 break;
6315 case PHONE_PLAY_LEVEL:
6316 retval = get_play_level(j);
6317 break;
6318 case IXJCTL_DSP_TYPE:
6319 retval = (j->dsp.high << 8) + j->dsp.low;
6320 break;
6321 case IXJCTL_DSP_VERSION:
6322 retval = (j->ver.high << 8) + j->ver.low;
6323 break;
6324 case IXJCTL_HZ:
6325 hertz = arg;
6326 break;
6327 case IXJCTL_RATE:
6328 if (arg > hertz)
6329 retval = -1;
6330 else
6331 samplerate = arg;
6332 break;
6333 case IXJCTL_DRYBUFFER_READ:
6334 put_user(j->drybuffer, (unsigned long __user *) argp);
6335 break;
6336 case IXJCTL_DRYBUFFER_CLEAR:
6337 j->drybuffer = 0;
6338 break;
6339 case IXJCTL_FRAMES_READ:
6340 put_user(j->framesread, (unsigned long __user *) argp);
6341 break;
6342 case IXJCTL_FRAMES_WRITTEN:
6343 put_user(j->frameswritten, (unsigned long __user *) argp);
6344 break;
6345 case IXJCTL_READ_WAIT:
6346 put_user(j->read_wait, (unsigned long __user *) argp);
6347 break;
6348 case IXJCTL_WRITE_WAIT:
6349 put_user(j->write_wait, (unsigned long __user *) argp);
6350 break;
6351 case PHONE_MAXRINGS:
6352 j->maxrings = arg;
6353 break;
6354 case PHONE_SET_TONE_ON_TIME:
6355 ixj_set_tone_on(arg, j);
6356 break;
6357 case PHONE_SET_TONE_OFF_TIME:
6358 ixj_set_tone_off(arg, j);
6359 break;
6360 case PHONE_GET_TONE_ON_TIME:
6361 if (ixj_get_tone_on(j)) {
6362 retval = -1;
6363 } else {
6364 retval = (j->ssr.high << 8) + j->ssr.low;
6365 }
6366 break;
6367 case PHONE_GET_TONE_OFF_TIME:
6368 if (ixj_get_tone_off(j)) {
6369 retval = -1;
6370 } else {
6371 retval = (j->ssr.high << 8) + j->ssr.low;
6372 }
6373 break;
6374 case PHONE_PLAY_TONE:
6375 if (!j->tone_state)
6376 retval = ixj_play_tone(j, arg);
6377 else
6378 retval = -1;
6379 break;
6380 case PHONE_GET_TONE_STATE:
6381 retval = j->tone_state;
6382 break;
6383 case PHONE_DTMF_READY:
6384 retval = j->ex.bits.dtmf_ready;
6385 break;
6386 case PHONE_GET_DTMF:
6387 if (ixj_hookstate(j)) {
6388 if (j->dtmf_rp != j->dtmf_wp) {
6389 retval = j->dtmfbuffer[j->dtmf_rp];
6390 j->dtmf_rp++;
6391 if (j->dtmf_rp == 79)
6392 j->dtmf_rp = 0;
6393 if (j->dtmf_rp == j->dtmf_wp) {
6394 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6395 }
6396 }
6397 }
6398 break;
6399 case PHONE_GET_DTMF_ASCII:
6400 if (ixj_hookstate(j)) {
6401 if (j->dtmf_rp != j->dtmf_wp) {
6402 switch (j->dtmfbuffer[j->dtmf_rp]) {
6403 case 10:
6404 retval = 42; /* '*'; */
6405
6406 break;
6407 case 11:
6408 retval = 48; /*'0'; */
6409
6410 break;
6411 case 12:
6412 retval = 35; /*'#'; */
6413
6414 break;
6415 case 28:
6416 retval = 65; /*'A'; */
6417
6418 break;
6419 case 29:
6420 retval = 66; /*'B'; */
6421
6422 break;
6423 case 30:
6424 retval = 67; /*'C'; */
6425
6426 break;
6427 case 31:
6428 retval = 68; /*'D'; */
6429
6430 break;
6431 default:
6432 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6433 break;
6434 }
6435 j->dtmf_rp++;
6436 if (j->dtmf_rp == 79)
6437 j->dtmf_rp = 0;
6438 if(j->dtmf_rp == j->dtmf_wp)
6439 {
6440 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6441 }
6442 }
6443 }
6444 break;
6445 case PHONE_DTMF_OOB:
6446 j->flags.dtmf_oob = arg;
6447 break;
6448 case PHONE_DIALTONE:
6449 ixj_dialtone(j);
6450 break;
6451 case PHONE_BUSY:
6452 ixj_busytone(j);
6453 break;
6454 case PHONE_RINGBACK:
6455 ixj_ringback(j);
6456 break;
6457 case PHONE_WINK:
6458 if(j->cardtype == QTI_PHONEJACK)
6459 retval = -1;
6460 else
6461 retval = ixj_wink(j);
6462 break;
6463 case PHONE_CPT_STOP:
6464 ixj_cpt_stop(j);
6465 break;
6466 case PHONE_QUERY_CODEC:
6467 {
6468 struct phone_codec_data pd;
6469 int val;
6470 int proto_size[] = {
6471 -1,
6472 12, 10, 16, 9, 8, 48, 5,
6473 40, 40, 80, 40, 40, 6
6474 };
6475 if(copy_from_user(&pd, argp, sizeof(pd))) {
6476 retval = -EFAULT;
6477 break;
6478 }
6479 if(pd.type<1 || pd.type>13) {
6480 retval = -EPROTONOSUPPORT;
6481 break;
6482 }
6483 if(pd.type<G729)
6484 val=proto_size[pd.type];
6485 else switch(j->baseframe.low)
6486 {
6487 case 0xA0:val=2*proto_size[pd.type];break;
6488 case 0x50:val=proto_size[pd.type];break;
6489 default:val=proto_size[pd.type]*3;break;
6490 }
6491 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6492 if(copy_to_user(argp, &pd, sizeof(pd)))
6493 retval = -EFAULT;
6494 break;
6495 }
6496 case IXJCTL_DSP_IDLE:
6497 idle(j);
6498 break;
6499 case IXJCTL_MIXER:
6500 if ((arg & 0xff) == 0xff)
6501 retval = ixj_get_mixer(arg, j);
6502 else
6503 ixj_mixer(arg, j);
6504 break;
6505 case IXJCTL_DAA_COEFF_SET:
6506 switch (arg) {
6507 case DAA_US:
6508 DAA_Coeff_US(j);
6509 retval = ixj_daa_write(j);
6510 break;
6511 case DAA_UK:
6512 DAA_Coeff_UK(j);
6513 retval = ixj_daa_write(j);
6514 break;
6515 case DAA_FRANCE:
6516 DAA_Coeff_France(j);
6517 retval = ixj_daa_write(j);
6518 break;
6519 case DAA_GERMANY:
6520 DAA_Coeff_Germany(j);
6521 retval = ixj_daa_write(j);
6522 break;
6523 case DAA_AUSTRALIA:
6524 DAA_Coeff_Australia(j);
6525 retval = ixj_daa_write(j);
6526 break;
6527 case DAA_JAPAN:
6528 DAA_Coeff_Japan(j);
6529 retval = ixj_daa_write(j);
6530 break;
6531 default:
6532 retval = 1;
6533 break;
6534 }
6535 break;
6536 case IXJCTL_DAA_AGAIN:
6537 ixj_daa_cr4(j, arg | 0x02);
6538 break;
6539 case IXJCTL_PSTN_LINETEST:
6540 retval = ixj_linetest(j);
6541 break;
6542 case IXJCTL_VMWI:
6543 ixj_write_vmwi(j, arg);
6544 break;
6545 case IXJCTL_CID:
6546 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6547 retval = -EFAULT;
6548 j->ex.bits.caller_id = 0;
6549 break;
6550 case IXJCTL_WINK_DURATION:
6551 j->winktime = arg;
6552 break;
6553 case IXJCTL_PORT:
6554 if (arg)
6555 retval = ixj_set_port(j, arg);
6556 else
6557 retval = j->port;
6558 break;
6559 case IXJCTL_POTS_PSTN:
6560 retval = ixj_set_pots(j, arg);
6561 break;
6562 case PHONE_CAPABILITIES:
6563 add_caps(j);
6564 retval = j->caps;
6565 break;
6566 case PHONE_CAPABILITIES_LIST:
6567 add_caps(j);
6568 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6569 retval = -EFAULT;
6570 break;
6571 case PHONE_CAPABILITIES_CHECK:
6572 {
6573 struct phone_capability cap;
6574 if (copy_from_user(&cap, argp, sizeof(cap)))
6575 retval = -EFAULT;
6576 else {
6577 add_caps(j);
6578 retval = capabilities_check(j, &cap);
6579 }
6580 }
6581 break;
6582 case PHONE_PSTN_SET_STATE:
6583 daa_set_mode(j, arg);
6584 break;
6585 case PHONE_PSTN_GET_STATE:
6586 retval = j->daa_mode;
6587 j->ex.bits.pstn_ring = 0;
6588 break;
6589 case IXJCTL_SET_FILTER:
6590 if (copy_from_user(&jf, argp, sizeof(jf)))
6591 retval = -EFAULT;
6592 retval = ixj_init_filter(j, &jf);
6593 break;
6594 case IXJCTL_SET_FILTER_RAW:
6595 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6596 retval = -EFAULT;
6597 else
6598 retval = ixj_init_filter_raw(j, &jfr);
6599 break;
6600 case IXJCTL_GET_FILTER_HIST:
6601 if(arg<0||arg>3)
6602 retval = -EINVAL;
6603 else
6604 retval = j->filter_hist[arg];
6605 break;
6606 case IXJCTL_INIT_TONE:
6607 if (copy_from_user(&ti, argp, sizeof(ti)))
6608 retval = -EFAULT;
6609 else
6610 retval = ixj_init_tone(j, &ti);
6611 break;
6612 case IXJCTL_TONE_CADENCE:
6613 retval = ixj_build_cadence(j, argp);
6614 break;
6615 case IXJCTL_FILTER_CADENCE:
6616 retval = ixj_build_filter_cadence(j, argp);
6617 break;
6618 case IXJCTL_SIGCTL:
6619 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6620 retval = -EFAULT;
6621 break;
6622 }
6623 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6624 if(j->sigdef.event < 33) {
6625 raise = 1;
6626 for(mant = 0; mant < j->sigdef.event; mant++){
6627 raise *= 2;
6628 }
6629 if(j->sigdef.signal)
6630 j->ex_sig.bytes |= raise;
6631 else
6632 j->ex_sig.bytes &= (raise^0xffff);
6633 }
6634 break;
6635 case IXJCTL_INTERCOM_STOP:
6636 if(arg < 0 || arg >= IXJMAX)
6637 return -EINVAL;
6638 j->intercom = -1;
6639 ixj_record_stop(j);
6640 ixj_play_stop(j);
6641 idle(j);
6642 get_ixj(arg)->intercom = -1;
6643 ixj_record_stop(get_ixj(arg));
6644 ixj_play_stop(get_ixj(arg));
6645 idle(get_ixj(arg));
6646 break;
6647 case IXJCTL_INTERCOM_START:
6648 if(arg < 0 || arg >= IXJMAX)
6649 return -EINVAL;
6650 j->intercom = arg;
6651 ixj_record_start(j);
6652 ixj_play_start(j);
6653 get_ixj(arg)->intercom = board;
6654 ixj_play_start(get_ixj(arg));
6655 ixj_record_start(get_ixj(arg));
6656 break;
6657 }
6658 if (ixjdebug & 0x0040)
6659 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6660 clear_bit(board, &j->busyflags);
6661 return retval;
6662 }
6663
6664 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6665 {
6666 long ret;
6667 lock_kernel();
6668 ret = do_ixj_ioctl(file_p, cmd, arg);
6669 unlock_kernel();
6670 return ret;
6671 }
6672
6673 static int ixj_fasync(int fd, struct file *file_p, int mode)
6674 {
6675 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6676
6677 return fasync_helper(fd, file_p, mode, &j->async_queue);
6678 }
6679
6680 static const struct file_operations ixj_fops =
6681 {
6682 .owner = THIS_MODULE,
6683 .read = ixj_enhanced_read,
6684 .write = ixj_enhanced_write,
6685 .poll = ixj_poll,
6686 .unlocked_ioctl = ixj_ioctl,
6687 .release = ixj_release,
6688 .fasync = ixj_fasync
6689 };
6690
6691 static int ixj_linetest(IXJ *j)
6692 {
6693 j->flags.pstncheck = 1; /* Testing */
6694 j->flags.pstn_present = 0; /* Assume the line is not there */
6695
6696 daa_int_read(j); /*Clear DAA Interrupt flags */
6697 /* */
6698 /* Hold all relays in the normally de-energized position. */
6699 /* */
6700
6701 j->pld_slicw.bits.rly1 = 0;
6702 j->pld_slicw.bits.rly2 = 0;
6703 j->pld_slicw.bits.rly3 = 0;
6704 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6705 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6706
6707 outb_p(j->pld_scrw.byte, j->XILINXbase);
6708 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6709 if (j->pld_slicr.bits.potspstn) {
6710 j->flags.pots_pstn = 1;
6711 j->flags.pots_correct = 0;
6712 LED_SetState(0x4, j);
6713 } else {
6714 j->flags.pots_pstn = 0;
6715 j->pld_slicw.bits.rly1 = 0;
6716 j->pld_slicw.bits.rly2 = 0;
6717 j->pld_slicw.bits.rly3 = 1;
6718 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6719 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6720
6721 outb_p(j->pld_scrw.byte, j->XILINXbase);
6722 daa_set_mode(j, SOP_PU_CONVERSATION);
6723 msleep(1000);
6724 daa_int_read(j);
6725 daa_set_mode(j, SOP_PU_RESET);
6726 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6727 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6728 LED_SetState(0x4, j);
6729 j->pld_slicw.bits.rly3 = 0;
6730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731 } else {
6732 j->flags.pots_correct = 1;
6733 LED_SetState(0x8, j);
6734 j->pld_slicw.bits.rly1 = 1;
6735 j->pld_slicw.bits.rly2 = 0;
6736 j->pld_slicw.bits.rly3 = 0;
6737 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6738 }
6739 }
6740 j->pld_slicw.bits.rly3 = 0;
6741 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6742 daa_set_mode(j, SOP_PU_CONVERSATION);
6743 msleep(1000);
6744 daa_int_read(j);
6745 daa_set_mode(j, SOP_PU_RESET);
6746 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6747 j->pstn_sleeptil = jiffies + (hertz / 4);
6748 j->flags.pstn_present = 1;
6749 } else {
6750 j->flags.pstn_present = 0;
6751 }
6752 if (j->flags.pstn_present) {
6753 if (j->flags.pots_correct) {
6754 LED_SetState(0xA, j);
6755 } else {
6756 LED_SetState(0x6, j);
6757 }
6758 } else {
6759 if (j->flags.pots_correct) {
6760 LED_SetState(0x9, j);
6761 } else {
6762 LED_SetState(0x5, j);
6763 }
6764 }
6765 j->flags.pstncheck = 0; /* Testing */
6766 return j->flags.pstn_present;
6767 }
6768
6769 static int ixj_selfprobe(IXJ *j)
6770 {
6771 unsigned short cmd;
6772 int cnt;
6773 BYTES bytes;
6774
6775 init_waitqueue_head(&j->poll_q);
6776 init_waitqueue_head(&j->read_q);
6777 init_waitqueue_head(&j->write_q);
6778
6779 while(atomic_read(&j->DSPWrite) > 0)
6780 atomic_dec(&j->DSPWrite);
6781 if (ixjdebug & 0x0002)
6782 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6783 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6784
6785 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6786 return -1;
6787 /* The read values of the SSR should be 0x00 for the IDLE command */
6788 if (j->ssr.low || j->ssr.high)
6789 return -1;
6790 if (ixjdebug & 0x0002)
6791 printk(KERN_INFO "Get Device ID Code\n");
6792 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6793 return -1;
6794 j->dsp.low = j->ssr.low;
6795 j->dsp.high = j->ssr.high;
6796 if (ixjdebug & 0x0002)
6797 printk(KERN_INFO "Get Device Version Code\n");
6798 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6799 return -1;
6800 j->ver.low = j->ssr.low;
6801 j->ver.high = j->ssr.high;
6802 if (!j->cardtype) {
6803 if (j->dsp.low == 0x21) {
6804 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6805 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6806 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6807 bytes.low = inb_p(j->XILINXbase + 0x02);
6808 if (bytes.low == bytes.high) /* Register is read only on */
6809 /* Internet PhoneJack Lite */
6810 {
6811 j->cardtype = QTI_PHONEJACK_LITE;
6812 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6813 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6814 return -1;
6815 }
6816 j->pld_slicw.pcib.e1 = 1;
6817 outb_p(j->pld_slicw.byte, j->XILINXbase);
6818 } else {
6819 j->cardtype = QTI_LINEJACK;
6820
6821 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6822 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6823 return -1;
6824 }
6825 }
6826 } else if (j->dsp.low == 0x22) {
6827 j->cardtype = QTI_PHONEJACK_PCI;
6828 request_region(j->XILINXbase, 4, "ixj control");
6829 j->pld_slicw.pcib.e1 = 1;
6830 outb_p(j->pld_slicw.byte, j->XILINXbase);
6831 } else
6832 j->cardtype = QTI_PHONEJACK;
6833 } else {
6834 switch (j->cardtype) {
6835 case QTI_PHONEJACK:
6836 if (!j->dsp.low != 0x20) {
6837 j->dsp.high = 0x80;
6838 j->dsp.low = 0x20;
6839 ixj_WriteDSPCommand(0x3800, j);
6840 j->ver.low = j->ssr.low;
6841 j->ver.high = j->ssr.high;
6842 }
6843 break;
6844 case QTI_LINEJACK:
6845 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6846 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6847 return -1;
6848 }
6849 break;
6850 case QTI_PHONEJACK_LITE:
6851 case QTI_PHONEJACK_PCI:
6852 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6853 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6854 return -1;
6855 }
6856 j->pld_slicw.pcib.e1 = 1;
6857 outb_p(j->pld_slicw.byte, j->XILINXbase);
6858 break;
6859 case QTI_PHONECARD:
6860 break;
6861 }
6862 }
6863 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6864 if (ixjdebug & 0x0002)
6865 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6866 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6867 return -1;
6868 if (ixjdebug & 0x0002)
6869 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6870 if (j->cardtype == QTI_PHONEJACK) {
6871 cmd = 0x9FF2;
6872 } else {
6873 cmd = 0x9FF5;
6874 }
6875 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6876 return -1;
6877 } else {
6878 if (set_base_frame(j, 30) != 30)
6879 return -1;
6880 if (ixjdebug & 0x0002)
6881 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6882 if (j->cardtype == QTI_PHONECARD) {
6883 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6884 return -1;
6885 }
6886 if (j->cardtype == QTI_LINEJACK) {
6887 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6888 return -1;
6889 if (ixjdebug & 0x0002)
6890 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6891 j->pld_clock.byte = 0;
6892 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6893 }
6894 }
6895
6896 if (j->dsp.low == 0x20) {
6897 if (ixjdebug & 0x0002)
6898 printk(KERN_INFO "Configure GPIO pins\n");
6899 j->gpio.bytes.high = 0x09;
6900 /* bytes.low = 0xEF; 0xF7 */
6901 j->gpio.bits.gpio1 = 1;
6902 j->gpio.bits.gpio2 = 1;
6903 j->gpio.bits.gpio3 = 0;
6904 j->gpio.bits.gpio4 = 1;
6905 j->gpio.bits.gpio5 = 1;
6906 j->gpio.bits.gpio6 = 1;
6907 j->gpio.bits.gpio7 = 1;
6908 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6909 if (ixjdebug & 0x0002)
6910 printk(KERN_INFO "Enable SLIC\n");
6911 j->gpio.bytes.high = 0x0B;
6912 j->gpio.bytes.low = 0x00;
6913 j->gpio.bits.gpio1 = 0;
6914 j->gpio.bits.gpio2 = 1;
6915 j->gpio.bits.gpio5 = 0;
6916 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6917 j->port = PORT_POTS;
6918 } else {
6919 if (j->cardtype == QTI_LINEJACK) {
6920 LED_SetState(0x1, j);
6921 msleep(100);
6922 LED_SetState(0x2, j);
6923 msleep(100);
6924 LED_SetState(0x4, j);
6925 msleep(100);
6926 LED_SetState(0x8, j);
6927 msleep(100);
6928 LED_SetState(0x0, j);
6929 daa_get_version(j);
6930 if (ixjdebug & 0x0002)
6931 printk("Loading DAA Coefficients\n");
6932 DAA_Coeff_US(j);
6933 if (!ixj_daa_write(j)) {
6934 printk("DAA write failed on board %d\n", j->board);
6935 return -1;
6936 }
6937 if(!ixj_daa_cid_reset(j)) {
6938 printk("DAA CID reset failed on board %d\n", j->board);
6939 return -1;
6940 }
6941 j->flags.pots_correct = 0;
6942 j->flags.pstn_present = 0;
6943 ixj_linetest(j);
6944 if (j->flags.pots_correct) {
6945 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6946
6947 outb_p(j->pld_scrw.byte, j->XILINXbase);
6948 j->pld_slicw.bits.rly1 = 1;
6949 j->pld_slicw.bits.spken = 1;
6950 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6951 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6952 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6953 j->port = PORT_POTS;
6954 }
6955 ixj_set_port(j, PORT_PSTN);
6956 ixj_set_pots(j, 1);
6957 if (ixjdebug & 0x0002)
6958 printk(KERN_INFO "Enable Mixer\n");
6959 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6960 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6961
6962 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6963 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6964
6965 ixj_mixer(0x0480, j); /*FM Left mute */
6966 ixj_mixer(0x0580, j); /*FM Right mute */
6967
6968 ixj_mixer(0x0680, j); /*CD Left mute */
6969 ixj_mixer(0x0780, j); /*CD Right mute */
6970
6971 ixj_mixer(0x0880, j); /*Line Left mute */
6972 ixj_mixer(0x0980, j); /*Line Right mute */
6973
6974 ixj_mixer(0x0A80, j); /*Aux left mute */
6975 ixj_mixer(0x0B80, j); /*Aux right mute */
6976
6977 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6978 ixj_mixer(0x0D80, j); /*Mono2 mute */
6979
6980 ixj_mixer(0x0E80, j); /*Mic mute */
6981
6982 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6983
6984 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6985 ixj_mixer(0x110C, j);
6986
6987
6988 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6989 ixj_mixer(0x1401, j);
6990
6991 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6992 ixj_mixer(0x1501, j);
6993
6994 ixj_mixer(0x1700, j); /*Clock select */
6995
6996 ixj_mixer(0x1800, j); /*ADC input from mixer */
6997
6998 ixj_mixer(0x1901, j); /*Mic gain 30db */
6999
7000 if (ixjdebug & 0x0002)
7001 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7002 j->cadence_f[4].state = 0;
7003 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7004 j->cadence_f[4].off1 = 0;
7005 j->cadence_f[4].on2 = 0;
7006 j->cadence_f[4].off2 = 0;
7007 j->cadence_f[4].on3 = 0;
7008 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7009 j->pstn_last_rmr = jiffies;
7010
7011 } else {
7012 if (j->cardtype == QTI_PHONECARD) {
7013 ixj_WriteDSPCommand(0xCF07, j);
7014 ixj_WriteDSPCommand(0x00B0, j);
7015 ixj_set_port(j, PORT_SPEAKER);
7016 } else {
7017 ixj_set_port(j, PORT_POTS);
7018 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7019 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7020 }
7021 }
7022 }
7023
7024 j->intercom = -1;
7025 j->framesread = j->frameswritten = 0;
7026 j->read_wait = j->write_wait = 0;
7027 j->rxreadycheck = j->txreadycheck = 0;
7028
7029 /* initialise the DTMF prescale to a sensible value */
7030 if (j->cardtype == QTI_LINEJACK) {
7031 set_dtmf_prescale(j, 0x10);
7032 } else {
7033 set_dtmf_prescale(j, 0x40);
7034 }
7035 set_play_volume(j, 0x100);
7036 set_rec_volume(j, 0x100);
7037
7038 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7039 return -1;
7040 /* The read values of the SSR should be 0x00 for the IDLE command */
7041 if (j->ssr.low || j->ssr.high)
7042 return -1;
7043
7044 if (ixjdebug & 0x0002)
7045 printk(KERN_INFO "Enable Line Monitor\n");
7046
7047 if (ixjdebug & 0x0002)
7048 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7049
7050 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7051 return -1;
7052
7053 if (ixjdebug & 0x002)
7054 printk(KERN_INFO "Enable DTMF Detectors\n");
7055
7056 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7057 return -1;
7058
7059 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7060 return -1;
7061
7062 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7063
7064 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7065
7066 j->ex.bits.dtmf_ready = 0;
7067 j->dtmf_state = 0;
7068 j->dtmf_wp = j->dtmf_rp = 0;
7069 j->rec_mode = j->play_mode = -1;
7070 j->flags.ringing = 0;
7071 j->maxrings = MAXRINGS;
7072 j->ring_cadence = USA_RING_CADENCE;
7073 j->drybuffer = 0;
7074 j->winktime = 320;
7075 j->flags.dtmf_oob = 0;
7076 for (cnt = 0; cnt < 4; cnt++)
7077 j->cadence_f[cnt].enable = 0;
7078 /* must be a device on the specified address */
7079 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7080
7081 /* Set up the default signals for events */
7082 for (cnt = 0; cnt < 35; cnt++)
7083 j->ixj_signals[cnt] = SIGIO;
7084
7085 /* Set the excetion signal enable flags */
7086 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7087 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 =
7088 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;
7089 #ifdef IXJ_DYN_ALLOC
7090 j->fskdata = NULL;
7091 #endif
7092 j->fskdcnt = 0;
7093 j->cidcw_wait = 0;
7094
7095 /* Register with the Telephony for Linux subsystem */
7096 j->p.f_op = &ixj_fops;
7097 j->p.open = ixj_open;
7098 j->p.board = j->board;
7099 phone_register_device(&j->p, PHONE_UNIT_ANY);
7100
7101 ixj_init_timer(j);
7102 ixj_add_timer(j);
7103 return 0;
7104 }
7105
7106 /*
7107 * Exported service for pcmcia card handling
7108 */
7109
7110 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7111 {
7112 IXJ *j = ixj_alloc();
7113
7114 j->board = 0;
7115
7116 j->DSPbase = dsp;
7117 j->XILINXbase = xilinx;
7118 j->cardtype = QTI_PHONECARD;
7119 ixj_selfprobe(j);
7120 return j;
7121 }
7122
7123 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7124
7125 static int ixj_get_status_proc(char *buf)
7126 {
7127 int len;
7128 int cnt;
7129 IXJ *j;
7130 len = 0;
7131 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7132 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7133 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7134 len += sprintf(buf + len, "\nUsing old telephony API");
7135 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7136
7137 for (cnt = 0; cnt < IXJMAX; cnt++) {
7138 j = get_ixj(cnt);
7139 if(j==NULL)
7140 continue;
7141 if (j->DSPbase) {
7142 len += sprintf(buf + len, "\nCard Num %d", cnt);
7143 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7144 if (j->cardtype != QTI_PHONEJACK)
7145 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7146 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7147 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7148 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7149 switch (j->cardtype) {
7150 case (QTI_PHONEJACK):
7151 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7152 break;
7153 case (QTI_LINEJACK):
7154 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7155 if (j->flags.g729_loaded)
7156 len += sprintf(buf + len, " w/G.729 A/B");
7157 len += sprintf(buf + len, " Country = %d", j->daa_country);
7158 break;
7159 case (QTI_PHONEJACK_LITE):
7160 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7161 if (j->flags.g729_loaded)
7162 len += sprintf(buf + len, " w/G.729 A/B");
7163 break;
7164 case (QTI_PHONEJACK_PCI):
7165 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7166 if (j->flags.g729_loaded)
7167 len += sprintf(buf + len, " w/G.729 A/B");
7168 break;
7169 case (QTI_PHONECARD):
7170 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7171 if (j->flags.g729_loaded)
7172 len += sprintf(buf + len, " w/G.729 A/B");
7173 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7174 if (!j->pccr1.bits.drf)
7175 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7176 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7177 break;
7178 default:
7179 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7180 break;
7181 }
7182 len += sprintf(buf + len, "\nReaders %d", j->readers);
7183 len += sprintf(buf + len, "\nWriters %d", j->writers);
7184 add_caps(j);
7185 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7186 if (j->dsp.low != 0x20)
7187 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7188 if (j->flags.cidsent)
7189 len += sprintf(buf + len, "\nCaller ID data sent");
7190 else
7191 len += sprintf(buf + len, "\nCaller ID data not sent");
7192
7193 len += sprintf(buf + len, "\nPlay CODEC ");
7194 switch (j->play_codec) {
7195 case G723_63:
7196 len += sprintf(buf + len, "G.723.1 6.3");
7197 break;
7198 case G723_53:
7199 len += sprintf(buf + len, "G.723.1 5.3");
7200 break;
7201 case TS85:
7202 len += sprintf(buf + len, "TrueSpeech 8.5");
7203 break;
7204 case TS48:
7205 len += sprintf(buf + len, "TrueSpeech 4.8");
7206 break;
7207 case TS41:
7208 len += sprintf(buf + len, "TrueSpeech 4.1");
7209 break;
7210 case G728:
7211 len += sprintf(buf + len, "G.728");
7212 break;
7213 case G729:
7214 len += sprintf(buf + len, "G.729");
7215 break;
7216 case G729B:
7217 len += sprintf(buf + len, "G.729B");
7218 break;
7219 case ULAW:
7220 len += sprintf(buf + len, "uLaw");
7221 break;
7222 case ALAW:
7223 len += sprintf(buf + len, "aLaw");
7224 break;
7225 case LINEAR16:
7226 len += sprintf(buf + len, "16 bit Linear");
7227 break;
7228 case LINEAR8:
7229 len += sprintf(buf + len, "8 bit Linear");
7230 break;
7231 case WSS:
7232 len += sprintf(buf + len, "Windows Sound System");
7233 break;
7234 default:
7235 len += sprintf(buf + len, "NO CODEC CHOSEN");
7236 break;
7237 }
7238 len += sprintf(buf + len, "\nRecord CODEC ");
7239 switch (j->rec_codec) {
7240 case G723_63:
7241 len += sprintf(buf + len, "G.723.1 6.3");
7242 break;
7243 case G723_53:
7244 len += sprintf(buf + len, "G.723.1 5.3");
7245 break;
7246 case TS85:
7247 len += sprintf(buf + len, "TrueSpeech 8.5");
7248 break;
7249 case TS48:
7250 len += sprintf(buf + len, "TrueSpeech 4.8");
7251 break;
7252 case TS41:
7253 len += sprintf(buf + len, "TrueSpeech 4.1");
7254 break;
7255 case G728:
7256 len += sprintf(buf + len, "G.728");
7257 break;
7258 case G729:
7259 len += sprintf(buf + len, "G.729");
7260 break;
7261 case G729B:
7262 len += sprintf(buf + len, "G.729B");
7263 break;
7264 case ULAW:
7265 len += sprintf(buf + len, "uLaw");
7266 break;
7267 case ALAW:
7268 len += sprintf(buf + len, "aLaw");
7269 break;
7270 case LINEAR16:
7271 len += sprintf(buf + len, "16 bit Linear");
7272 break;
7273 case LINEAR8:
7274 len += sprintf(buf + len, "8 bit Linear");
7275 break;
7276 case WSS:
7277 len += sprintf(buf + len, "Windows Sound System");
7278 break;
7279 default:
7280 len += sprintf(buf + len, "NO CODEC CHOSEN");
7281 break;
7282 }
7283 len += sprintf(buf + len, "\nAEC ");
7284 switch (j->aec_level) {
7285 case AEC_OFF:
7286 len += sprintf(buf + len, "Off");
7287 break;
7288 case AEC_LOW:
7289 len += sprintf(buf + len, "Low");
7290 break;
7291 case AEC_MED:
7292 len += sprintf(buf + len, "Med");
7293 break;
7294 case AEC_HIGH:
7295 len += sprintf(buf + len, "High");
7296 break;
7297 case AEC_AUTO:
7298 len += sprintf(buf + len, "Auto");
7299 break;
7300 case AEC_AGC:
7301 len += sprintf(buf + len, "AEC/AGC");
7302 break;
7303 default:
7304 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7305 break;
7306 }
7307
7308 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7309 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7310 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7311
7312 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7313
7314 if (j->cardtype == QTI_LINEJACK) {
7315 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7316 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7317 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7318 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7319 switch (j->daa_mode) {
7320 case SOP_PU_SLEEP:
7321 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7322 break;
7323 case SOP_PU_RINGING:
7324 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7325 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7326 break;
7327 case SOP_PU_CONVERSATION:
7328 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7329 break;
7330 case SOP_PU_PULSEDIALING:
7331 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7332 break;
7333 }
7334 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7335 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7336 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7337 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7338 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7339 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7340 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7341 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7342 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7343 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7344 }
7345 switch (j->port) {
7346 case PORT_POTS:
7347 len += sprintf(buf + len, "\nPort POTS");
7348 break;
7349 case PORT_PSTN:
7350 len += sprintf(buf + len, "\nPort PSTN");
7351 break;
7352 case PORT_SPEAKER:
7353 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7354 break;
7355 case PORT_HANDSET:
7356 len += sprintf(buf + len, "\nPort HANDSET");
7357 break;
7358 }
7359 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7360 len += sprintf(buf + len, "\nSLIC state ");
7361 switch (SLIC_GetState(j)) {
7362 case PLD_SLIC_STATE_OC:
7363 len += sprintf(buf + len, "OC");
7364 break;
7365 case PLD_SLIC_STATE_RINGING:
7366 len += sprintf(buf + len, "RINGING");
7367 break;
7368 case PLD_SLIC_STATE_ACTIVE:
7369 len += sprintf(buf + len, "ACTIVE");
7370 break;
7371 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7372 len += sprintf(buf + len, "OHT");
7373 break;
7374 case PLD_SLIC_STATE_TIPOPEN:
7375 len += sprintf(buf + len, "TIPOPEN");
7376 break;
7377 case PLD_SLIC_STATE_STANDBY:
7378 len += sprintf(buf + len, "STANDBY");
7379 break;
7380 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7381 len += sprintf(buf + len, "APR");
7382 break;
7383 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7384 len += sprintf(buf + len, "OHTPR");
7385 break;
7386 default:
7387 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7388 break;
7389 }
7390 }
7391 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7392 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7393 #ifdef PERFMON_STATS
7394 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7395 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7396 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7397 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7398 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7399 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7400 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7401 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7402 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7403 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7404 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7405 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7406 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7407 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7408
7409 #endif
7410 len += sprintf(buf + len, "\n");
7411 }
7412 }
7413 return len;
7414 }
7415
7416 static int ixj_read_proc(char *page, char **start, off_t off,
7417 int count, int *eof, void *data)
7418 {
7419 int len = ixj_get_status_proc(page);
7420 if (len <= off+count) *eof = 1;
7421 *start = page + off;
7422 len -= off;
7423 if (len>count) len = count;
7424 if (len<0) len = 0;
7425 return len;
7426 }
7427
7428
7429 static void cleanup(void)
7430 {
7431 int cnt;
7432 IXJ *j;
7433
7434 for (cnt = 0; cnt < IXJMAX; cnt++) {
7435 j = get_ixj(cnt);
7436 if(j != NULL && j->DSPbase) {
7437 if (ixjdebug & 0x0002)
7438 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7439 del_timer(&j->timer);
7440 if (j->cardtype == QTI_LINEJACK) {
7441 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7442
7443 outb_p(j->pld_scrw.byte, j->XILINXbase);
7444 j->pld_slicw.bits.rly1 = 0;
7445 j->pld_slicw.bits.rly2 = 0;
7446 j->pld_slicw.bits.rly3 = 0;
7447 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7448 LED_SetState(0x0, j);
7449 if (ixjdebug & 0x0002)
7450 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7451 release_region(j->XILINXbase, 8);
7452 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7453 if (ixjdebug & 0x0002)
7454 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7455 release_region(j->XILINXbase, 4);
7456 }
7457 kfree(j->read_buffer);
7458 kfree(j->write_buffer);
7459 if (j->dev)
7460 pnp_device_detach(j->dev);
7461 if (ixjdebug & 0x0002)
7462 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7463 phone_unregister_device(&j->p);
7464 if (ixjdebug & 0x0002)
7465 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7466 release_region(j->DSPbase, 16);
7467 #ifdef IXJ_DYN_ALLOC
7468 if (ixjdebug & 0x0002)
7469 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7470 kfree(j);
7471 ixj[cnt] = NULL;
7472 #endif
7473 }
7474 }
7475 if (ixjdebug & 0x0002)
7476 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7477 remove_proc_entry ("ixj", NULL);
7478 }
7479
7480 /* Typedefs */
7481 typedef struct {
7482 BYTE length;
7483 DWORD bits;
7484 } DATABLOCK;
7485
7486 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7487 {
7488 lastLCC = lastLCC & 0xfb;
7489 lastLCC = lastLCC | (byData ? 4 : 0);
7490 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7491
7492 mdelay(1);
7493 lastLCC = lastLCC | 0x01;
7494 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7495
7496 byData = byData << 1;
7497 lastLCC = lastLCC & 0xfe;
7498 mdelay(1);
7499 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7500
7501 }
7502
7503 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7504 {
7505 mdelay(1);
7506 lastLCC = lastLCC | 0x01;
7507 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7508
7509 lastLCC = lastLCC & 0xfe;
7510 mdelay(1);
7511 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7512
7513 return ((inb(wEEPROMAddress) >> 3) & 1);
7514 }
7515
7516 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7517 {
7518 BYTE lastLCC;
7519 WORD wEEPROMAddress = wAddress + 3;
7520 DWORD i;
7521 BYTE byResult;
7522 *pwResult = 0;
7523 lastLCC = inb(wEEPROMAddress);
7524 lastLCC = lastLCC | 0x02;
7525 lastLCC = lastLCC & 0xfe;
7526 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7527
7528 mdelay(1); /* delay */
7529
7530 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7531 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7532 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7533 for (i = 0; i < 8; i++) {
7534 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7535 wLoc <<= 1;
7536 }
7537
7538 for (i = 0; i < 16; i++) {
7539 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7540 *pwResult = (*pwResult << 1) | byResult;
7541 }
7542
7543 mdelay(1); /* another delay */
7544
7545 lastLCC = lastLCC & 0xfd;
7546 outb(lastLCC, wEEPROMAddress); /* negate CS */
7547
7548 return 0;
7549 }
7550
7551 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7552 {
7553 WORD wLo, wHi;
7554 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7555 return 0;
7556 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7557 return 0;
7558 return (((DWORD) wHi << 16) | wLo);
7559 }
7560
7561 static int dspio[IXJMAX + 1] =
7562 {
7563 0,
7564 };
7565 static int xio[IXJMAX + 1] =
7566 {
7567 0,
7568 };
7569
7570 module_param_array(dspio, int, NULL, 0);
7571 module_param_array(xio, int, NULL, 0);
7572 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7573 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7574 MODULE_LICENSE("GPL");
7575
7576 static void __exit ixj_exit(void)
7577 {
7578 cleanup();
7579 }
7580
7581 static IXJ *new_ixj(unsigned long port)
7582 {
7583 IXJ *res;
7584 if (!request_region(port, 16, "ixj DSP")) {
7585 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7586 return NULL;
7587 }
7588 res = ixj_alloc();
7589 if (!res) {
7590 release_region(port, 16);
7591 printk(KERN_INFO "ixj: out of memory\n");
7592 return NULL;
7593 }
7594 res->DSPbase = port;
7595 return res;
7596 }
7597
7598 static int __init ixj_probe_isapnp(int *cnt)
7599 {
7600 int probe = 0;
7601 int func = 0x110;
7602 struct pnp_dev *dev = NULL, *old_dev = NULL;
7603
7604 while (1) {
7605 do {
7606 IXJ *j;
7607 int result;
7608
7609 old_dev = dev;
7610 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7611 ISAPNP_FUNCTION(func), old_dev);
7612 if (!dev || !dev->card)
7613 break;
7614 result = pnp_device_attach(dev);
7615 if (result < 0) {
7616 printk("pnp attach failed %d \n", result);
7617 break;
7618 }
7619 if (pnp_activate_dev(dev) < 0) {
7620 printk("pnp activate failed (out of resources?)\n");
7621 pnp_device_detach(dev);
7622 return -ENOMEM;
7623 }
7624
7625 if (!pnp_port_valid(dev, 0)) {
7626 pnp_device_detach(dev);
7627 return -ENODEV;
7628 }
7629
7630 j = new_ixj(pnp_port_start(dev, 0));
7631 if (!j)
7632 break;
7633
7634 if (func != 0x110)
7635 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7636
7637 switch (func) {
7638 case (0x110):
7639 j->cardtype = QTI_PHONEJACK;
7640 break;
7641 case (0x310):
7642 j->cardtype = QTI_LINEJACK;
7643 break;
7644 case (0x410):
7645 j->cardtype = QTI_PHONEJACK_LITE;
7646 break;
7647 }
7648 j->board = *cnt;
7649 probe = ixj_selfprobe(j);
7650 if(!probe) {
7651 j->serial = dev->card->serial;
7652 j->dev = dev;
7653 switch (func) {
7654 case 0x110:
7655 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7656 break;
7657 case 0x310:
7658 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7659 break;
7660 case 0x410:
7661 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7662 break;
7663 }
7664 }
7665 ++*cnt;
7666 } while (dev);
7667 if (func == 0x410)
7668 break;
7669 if (func == 0x310)
7670 func = 0x410;
7671 if (func == 0x110)
7672 func = 0x310;
7673 dev = NULL;
7674 }
7675 return probe;
7676 }
7677
7678 static int __init ixj_probe_isa(int *cnt)
7679 {
7680 int i, probe;
7681
7682 /* Use passed parameters for older kernels without PnP */
7683 for (i = 0; i < IXJMAX; i++) {
7684 if (dspio[i]) {
7685 IXJ *j = new_ixj(dspio[i]);
7686
7687 if (!j)
7688 break;
7689
7690 j->XILINXbase = xio[i];
7691 j->cardtype = 0;
7692
7693 j->board = *cnt;
7694 probe = ixj_selfprobe(j);
7695 j->dev = NULL;
7696 ++*cnt;
7697 }
7698 }
7699 return 0;
7700 }
7701
7702 static int __init ixj_probe_pci(int *cnt)
7703 {
7704 struct pci_dev *pci = NULL;
7705 int i, probe = 0;
7706 IXJ *j = NULL;
7707
7708 for (i = 0; i < IXJMAX - *cnt; i++) {
7709 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7710 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7711 if (!pci)
7712 break;
7713
7714 if (pci_enable_device(pci))
7715 break;
7716 j = new_ixj(pci_resource_start(pci, 0));
7717 if (!j)
7718 break;
7719
7720 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7721 j->XILINXbase = j->DSPbase + 0x10;
7722 j->cardtype = QTI_PHONEJACK_PCI;
7723 j->board = *cnt;
7724 probe = ixj_selfprobe(j);
7725 if (!probe)
7726 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7727 ++*cnt;
7728 }
7729 pci_dev_put(pci);
7730 return probe;
7731 }
7732
7733 static int __init ixj_init(void)
7734 {
7735 int cnt = 0;
7736 int probe = 0;
7737
7738 cnt = 0;
7739
7740 /* These might be no-ops, see above. */
7741 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7742 return probe;
7743 }
7744 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7745 return probe;
7746 }
7747 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7748 return probe;
7749 }
7750 printk(KERN_INFO "ixj driver initialized.\n");
7751 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7752 return probe;
7753 }
7754
7755 module_init(ixj_init);
7756 module_exit(ixj_exit);
7757
7758 static void DAA_Coeff_US(IXJ *j)
7759 {
7760 int i;
7761
7762 j->daa_country = DAA_US;
7763 /*----------------------------------------------- */
7764 /* CAO */
7765 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7766 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7767 }
7768
7769 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7778 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7779 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7780 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7781 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7782 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7783 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7784 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7785 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7786 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7787 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7796 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7797 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7798 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7799 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7800 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7801 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7802 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7803 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7804 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7805 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7806 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7807 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7808 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7809 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7810 /* Bytes for AR-filter (09): 52,D3,11,42 */
7811 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7812 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7813 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7814 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7815 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7824 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7833 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7834 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7835 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7836 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7837 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7838 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7839 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7840 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7841 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7842 /* ; (10K, 0.68uF) */
7843 /* */
7844 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7853 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7854 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7855 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7856 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7857 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7858 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7859 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7860 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7861 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7862
7863 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7864 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7865 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7866 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7867 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7868
7869 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7870 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7871 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7872 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7876 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7877 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7878 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7879 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7880 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7881 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7884 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7885 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7886 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7887 /* */
7888 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7889 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7890 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7891 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7892 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7893
7894 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7903 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7904 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7905 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7906 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7907 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7908 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7909 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7910 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7911 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7912 /* */
7913 /* ;CR Registers */
7914 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7916 /* Config. Reg. 1 (dialing) (cr1):05 */
7917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7918 /* Config. Reg. 2 (caller ID) (cr2):04 */
7919 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7920 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7921 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7922 /* Config. Reg. 4 (analog gain) (cr4):02 */
7923 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7924 /* Config. Reg. 5 (Version) (cr5):02 */
7925 /* Config. Reg. 6 (Reserved) (cr6):00 */
7926 /* Config. Reg. 7 (Reserved) (cr7):00 */
7927 /* */
7928 /* ;xr Registers */
7929 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7930
7931 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7932 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7933
7934 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7935 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7936 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7937 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7938 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7939 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7940
7941 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7942 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7943 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7944 /* Ext. Reg. 6 (Power State) (xr6):00 */
7945 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7946 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7947 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7948 /* */
7949 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7950 /* 12,33,5A,C3 ; 770 Hz */
7951 /* 13,3C,5B,32 ; 852 Hz */
7952 /* 1D,1B,5C,CC ; 941 Hz */
7953
7954 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7957 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7958 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7959 /* EC,1D,52,22 ; 1336 Hz */
7960 /* AA,AC,51,D2 ; 1477 Hz */
7961 /* 9B,3B,51,25 ; 1633 Hz */
7962 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7963 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7964 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7965 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7966 }
7967
7968 static void DAA_Coeff_UK(IXJ *j)
7969 {
7970 int i;
7971
7972 j->daa_country = DAA_UK;
7973 /*----------------------------------------------- */
7974 /* CAO */
7975 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7976 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7977 }
7978
7979 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7988 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7989 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7990 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7991 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7992 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7993 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7994 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7995 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7996 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7997 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8006 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8007 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8008 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8009 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8010 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8011 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8012 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8013 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8014 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8015 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8016 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8017 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8018 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8019 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8020 /* Bytes for AR-filter (09): E2,27,10,D6 */
8021 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8022 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8023 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8024 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8025 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8034 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8043 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8044 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8045 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8046 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8047 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8048 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8049 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8050 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8051 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8052 /* ; idle */
8053 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8062 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8063 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8064 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8065 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8066 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8067 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8068 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8069 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8070 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8071 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8072 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8073 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8074 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8075 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8076 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8085 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8086 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8087 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8088 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8089 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8090 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8091 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8092 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8093 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8094 /* ;CR Registers */
8095 /* Config. Reg. 0 (filters) (cr0):FF */
8096 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8097 /* Config. Reg. 1 (dialing) (cr1):05 */
8098 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8099 /* Config. Reg. 2 (caller ID) (cr2):04 */
8100 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8101 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8102 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8103 /* Config. Reg. 4 (analog gain) (cr4):02 */
8104 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8105 /* Config. Reg. 5 (Version) (cr5):02 */
8106 /* Config. Reg. 6 (Reserved) (cr6):00 */
8107 /* Config. Reg. 7 (Reserved) (cr7):00 */
8108 /* ;xr Registers */
8109 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8110
8111 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8112 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8113
8114 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8115 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8116
8117 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8118 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8119 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8120 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8121 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8122 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8123 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8124 /* Ext. Reg. 6 (Power State) (xr6):00 */
8125 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8126 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8127 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8128 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8129 /* 12,33,5A,C3 ; 770 Hz */
8130 /* 13,3C,5B,32 ; 852 Hz */
8131 /* 1D,1B,5C,CC ; 941 Hz */
8132
8133 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8136 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8137 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8138 /* EC,1D,52,22 ; 1336 Hz */
8139 /* AA,AC,51,D2 ; 1477 Hz */
8140 /* 9B,3B,51,25 ; 1633 Hz */
8141 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8142 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8143 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8144 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8145 }
8146
8147
8148 static void DAA_Coeff_France(IXJ *j)
8149 {
8150 int i;
8151
8152 j->daa_country = DAA_FRANCE;
8153 /*----------------------------------------------- */
8154 /* CAO */
8155 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8156 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8157 }
8158
8159 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8168 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8169 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8170 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8171 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8172 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8173 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8174 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8175 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8176 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8177 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8186 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8187 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8188 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8189 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8190 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8191 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8192 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8193 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8194 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8195 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8196 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8197 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8198 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8199 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8200 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8201 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8202 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8203 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8204 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8205 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8214 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8223 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8224 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8225 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8226 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8227 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8228 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8229 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8230 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8231 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8232 /* ; idle */
8233 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8242 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8243 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8244 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8245 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8246 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8247 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8248 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8249 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8250 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8251 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8252 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8253 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8254 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8255 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8256 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8265 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8266 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8267 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8268 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8269 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8270 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8271 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8272 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8273 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8274 /* ;CR Registers */
8275 /* Config. Reg. 0 (filters) (cr0):FF */
8276 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8277 /* Config. Reg. 1 (dialing) (cr1):05 */
8278 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8279 /* Config. Reg. 2 (caller ID) (cr2):04 */
8280 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8281 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8282 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8283 /* Config. Reg. 4 (analog gain) (cr4):02 */
8284 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8285 /* Config. Reg. 5 (Version) (cr5):02 */
8286 /* Config. Reg. 6 (Reserved) (cr6):00 */
8287 /* Config. Reg. 7 (Reserved) (cr7):00 */
8288 /* ;xr Registers */
8289 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8290
8291 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8292 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8293
8294 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8295 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8296
8297 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8298 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8299 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8300 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8301 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8302 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8303 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8304 /* Ext. Reg. 6 (Power State) (xr6):00 */
8305 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8306 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8307 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8308 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8309 /* 12,33,5A,C3 ; 770 Hz */
8310 /* 13,3C,5B,32 ; 852 Hz */
8311 /* 1D,1B,5C,CC ; 941 Hz */
8312
8313 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8316 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8317 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8318 /* EC,1D,52,22 ; 1336 Hz */
8319 /* AA,AC,51,D2 ; 1477 Hz */
8320 /* 9B,3B,51,25 ; 1633 Hz */
8321 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8322 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8323 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8324 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8325 }
8326
8327
8328 static void DAA_Coeff_Germany(IXJ *j)
8329 {
8330 int i;
8331
8332 j->daa_country = DAA_GERMANY;
8333 /*----------------------------------------------- */
8334 /* CAO */
8335 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8336 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8337 }
8338
8339 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8348 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8349 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8350 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8351 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8352 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8353 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8354 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8355 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8356 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8357 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8366 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8367 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8368 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8369 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8370 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8371 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8372 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8373 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8374 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8375 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8376 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8377 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8378 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8379 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8380 /* Bytes for AR-filter (09): 72,42,13,4B */
8381 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8382 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8383 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8384 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8385 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8394 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8403 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8404 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8405 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8406 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8407 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8408 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8409 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8410 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8411 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8412 /* ; (10K, 0.68uF) */
8413 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8422 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8423 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8424 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8425 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8426 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8427 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8428 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8429 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8430 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8431 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8432 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8433 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8434 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8435 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8436 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8445 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8446 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8447 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8448 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8449 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8450 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8451 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8452 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8453 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8454 /* ;CR Registers */
8455 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8456 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8457 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8458 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8459 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8460 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8461 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8462 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8463 /* Config. Reg. 4 (analog gain) (cr4):02 */
8464 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8465 /* Config. Reg. 5 (Version) (cr5):02 */
8466 /* Config. Reg. 6 (Reserved) (cr6):00 */
8467 /* Config. Reg. 7 (Reserved) (cr7):00 */
8468 /* ;xr Registers */
8469 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8470
8471 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8472 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8473
8474 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8475 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8476
8477 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8478 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8479 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8480 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8481 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8482 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8483 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8484 /* Ext. Reg. 6 (Power State) (xr6):00 */
8485 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8486 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8487 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8488 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8489 /* 12,33,5A,C3 ; 770 Hz */
8490 /* 13,3C,5B,32 ; 852 Hz */
8491 /* 1D,1B,5C,CC ; 941 Hz */
8492
8493 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8496 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8497 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8498 /* EC,1D,52,22 ; 1336 Hz */
8499 /* AA,AC,51,D2 ; 1477 Hz */
8500 /* 9B,3B,51,25 ; 1633 Hz */
8501 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8502 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8503 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8504 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8505 }
8506
8507
8508 static void DAA_Coeff_Australia(IXJ *j)
8509 {
8510 int i;
8511
8512 j->daa_country = DAA_AUSTRALIA;
8513 /*----------------------------------------------- */
8514 /* CAO */
8515 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8516 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8517 }
8518
8519 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8528 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8529 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8530 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8531 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8532 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8533 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8534 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8535 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8536 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8537 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8546 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8547 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8548 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8549 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8550 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8551 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8552 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8553 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8554 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8555 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8556 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8557 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8558 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8559 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8560 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8561 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8562 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8563 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8564 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8565 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8574 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8583 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8584 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8585 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8586 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8587 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8588 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8589 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8590 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8591 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8592 /* ; idle */
8593 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8602 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8603 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8604 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8605 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8606 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8607 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8608 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8609 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8610 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8611 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8612 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8613 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8614 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8615 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8616 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8625 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8626 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8627 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8628 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8629 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8630 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8631 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8632 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8633 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8634 /* ;CR Registers */
8635 /* Config. Reg. 0 (filters) (cr0):FF */
8636 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8637 /* Config. Reg. 1 (dialing) (cr1):05 */
8638 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8639 /* Config. Reg. 2 (caller ID) (cr2):04 */
8640 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8641 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8642 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8643 /* Config. Reg. 4 (analog gain) (cr4):02 */
8644 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8645 /* Config. Reg. 5 (Version) (cr5):02 */
8646 /* Config. Reg. 6 (Reserved) (cr6):00 */
8647 /* Config. Reg. 7 (Reserved) (cr7):00 */
8648 /* ;xr Registers */
8649 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8650
8651 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8652 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8653
8654 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8655 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8656
8657 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8658 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8659 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8660 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8661 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8662 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8663 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8664 /* Ext. Reg. 6 (Power State) (xr6):00 */
8665 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8666 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8667 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8668
8669 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8670 /* 12,33,5A,C3 ; 770 Hz */
8671 /* 13,3C,5B,32 ; 852 Hz */
8672 /* 1D,1B,5C,CC ; 941 Hz */
8673 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8674 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8675 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8677
8678 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8679 /* EC,1D,52,22 ; 1336 Hz */
8680 /* AA,AC,51,D2 ; 1477 Hz */
8681 /* 9B,3B,51,25 ; 1633 Hz */
8682 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8683 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8684 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8685 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8686 }
8687
8688 static void DAA_Coeff_Japan(IXJ *j)
8689 {
8690 int i;
8691
8692 j->daa_country = DAA_JAPAN;
8693 /*----------------------------------------------- */
8694 /* CAO */
8695 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8696 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8697 }
8698
8699 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8708 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8709 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8710 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8711 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8712 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8713 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8714 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8715 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8716 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8717 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8726 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8727 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8728 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8729 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8730 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8731 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8732 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8733 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8734 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8735 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8736 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8737 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8738 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8739 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8740 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8741 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8742 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8743 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8744 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8745 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8754 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8763 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8764 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8765 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8766 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8767 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8768 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8769 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8770 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8771 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8772 /* ; idle */
8773 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8782 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8783 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8784 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8785 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8786 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8787 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8788 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8789 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8790 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8791 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8792 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8793 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8794 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8795 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8796 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8805 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8806 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8807 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8808 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8809 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8810 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8811 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8812 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8813 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8814 /* ;CR Registers */
8815 /* Config. Reg. 0 (filters) (cr0):FF */
8816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8817 /* Config. Reg. 1 (dialing) (cr1):05 */
8818 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8819 /* Config. Reg. 2 (caller ID) (cr2):04 */
8820 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8821 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8822 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8823 /* Config. Reg. 4 (analog gain) (cr4):02 */
8824 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8825 /* Config. Reg. 5 (Version) (cr5):02 */
8826 /* Config. Reg. 6 (Reserved) (cr6):00 */
8827 /* Config. Reg. 7 (Reserved) (cr7):00 */
8828 /* ;xr Registers */
8829 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8830
8831 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8832 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8833
8834 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8835 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8836
8837 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8838 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8839 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8840 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8841 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8842 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8843 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8844 /* Ext. Reg. 6 (Power State) (xr6):00 */
8845 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8846 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8847 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8848 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8849 /* 12,33,5A,C3 ; 770 Hz */
8850 /* 13,3C,5B,32 ; 852 Hz */
8851 /* 1D,1B,5C,CC ; 941 Hz */
8852
8853 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8856 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8857 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8858 /* EC,1D,52,22 ; 1336 Hz */
8859 /* AA,AC,51,D2 ; 1477 Hz */
8860 /* 9B,3B,51,25 ; 1633 Hz */
8861 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8862 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8863 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8864 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8865 }
8866
8867 static s16 tone_table[][19] =
8868 {
8869 { /* f20_50[] 11 */
8870 32538, /* A1 = 1.985962 */
8871 -32325, /* A2 = -0.986511 */
8872 -343, /* B2 = -0.010493 */
8873 0, /* B1 = 0 */
8874 343, /* B0 = 0.010493 */
8875 32619, /* A1 = 1.990906 */
8876 -32520, /* A2 = -0.992462 */
8877 19179, /* B2 = 0.585327 */
8878 -19178, /* B1 = -1.170593 */
8879 19179, /* B0 = 0.585327 */
8880 32723, /* A1 = 1.997314 */
8881 -32686, /* A2 = -0.997528 */
8882 9973, /* B2 = 0.304352 */
8883 -9955, /* B1 = -0.607605 */
8884 9973, /* B0 = 0.304352 */
8885 7, /* Internal filter scaling */
8886 159, /* Minimum in-band energy threshold */
8887 21, /* 21/32 in-band to broad-band ratio */
8888 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8889 },
8890 { /* f133_200[] 12 */
8891 32072, /* A1 = 1.95752 */
8892 -31896, /* A2 = -0.973419 */
8893 -435, /* B2 = -0.013294 */
8894 0, /* B1 = 0 */
8895 435, /* B0 = 0.013294 */
8896 32188, /* A1 = 1.9646 */
8897 -32400, /* A2 = -0.98877 */
8898 15139, /* B2 = 0.462036 */
8899 -14882, /* B1 = -0.908356 */
8900 15139, /* B0 = 0.462036 */
8901 32473, /* A1 = 1.981995 */
8902 -32524, /* A2 = -0.992584 */
8903 23200, /* B2 = 0.708008 */
8904 -23113, /* B1 = -1.410706 */
8905 23200, /* B0 = 0.708008 */
8906 7, /* Internal filter scaling */
8907 159, /* Minimum in-band energy threshold */
8908 21, /* 21/32 in-band to broad-band ratio */
8909 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8910 },
8911 { /* f300 13 */
8912 31769, /* A1 = -1.939026 */
8913 -32584, /* A2 = 0.994385 */
8914 -475, /* B2 = -0.014522 */
8915 0, /* B1 = 0.000000 */
8916 475, /* B0 = 0.014522 */
8917 31789, /* A1 = -1.940247 */
8918 -32679, /* A2 = 0.997284 */
8919 17280, /* B2 = 0.527344 */
8920 -16865, /* B1 = -1.029358 */
8921 17280, /* B0 = 0.527344 */
8922 31841, /* A1 = -1.943481 */
8923 -32681, /* A2 = 0.997345 */
8924 543, /* B2 = 0.016579 */
8925 -525, /* B1 = -0.032097 */
8926 543, /* B0 = 0.016579 */
8927 5, /* Internal filter scaling */
8928 159, /* Minimum in-band energy threshold */
8929 21, /* 21/32 in-band to broad-band ratio */
8930 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8931 },
8932 { /* f300_420[] 14 */
8933 30750, /* A1 = 1.876892 */
8934 -31212, /* A2 = -0.952515 */
8935 -804, /* B2 = -0.024541 */
8936 0, /* B1 = 0 */
8937 804, /* B0 = 0.024541 */
8938 30686, /* A1 = 1.872925 */
8939 -32145, /* A2 = -0.980988 */
8940 14747, /* B2 = 0.450043 */
8941 -13703, /* B1 = -0.836395 */
8942 14747, /* B0 = 0.450043 */
8943 31651, /* A1 = 1.931824 */
8944 -32321, /* A2 = -0.986389 */
8945 24425, /* B2 = 0.745422 */
8946 -23914, /* B1 = -1.459595 */
8947 24427, /* B0 = 0.745483 */
8948 7, /* Internal filter scaling */
8949 159, /* Minimum in-band energy threshold */
8950 21, /* 21/32 in-band to broad-band ratio */
8951 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8952 },
8953 { /* f330 15 */
8954 31613, /* A1 = -1.929565 */
8955 -32646, /* A2 = 0.996277 */
8956 -185, /* B2 = -0.005657 */
8957 0, /* B1 = 0.000000 */
8958 185, /* B0 = 0.005657 */
8959 31620, /* A1 = -1.929932 */
8960 -32713, /* A2 = 0.998352 */
8961 19253, /* B2 = 0.587585 */
8962 -18566, /* B1 = -1.133179 */
8963 19253, /* B0 = 0.587585 */
8964 31674, /* A1 = -1.933228 */
8965 -32715, /* A2 = 0.998413 */
8966 2575, /* B2 = 0.078590 */
8967 -2495, /* B1 = -0.152283 */
8968 2575, /* B0 = 0.078590 */
8969 5, /* Internal filter scaling */
8970 159, /* Minimum in-band energy threshold */
8971 21, /* 21/32 in-band to broad-band ratio */
8972 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8973 },
8974 { /* f300_425[] 16 */
8975 30741, /* A1 = 1.876282 */
8976 -31475, /* A2 = -0.960541 */
8977 -703, /* B2 = -0.021484 */
8978 0, /* B1 = 0 */
8979 703, /* B0 = 0.021484 */
8980 30688, /* A1 = 1.873047 */
8981 -32248, /* A2 = -0.984161 */
8982 14542, /* B2 = 0.443787 */
8983 -13523, /* B1 = -0.825439 */
8984 14542, /* B0 = 0.443817 */
8985 31494, /* A1 = 1.922302 */
8986 -32366, /* A2 = -0.987762 */
8987 21577, /* B2 = 0.658508 */
8988 -21013, /* B1 = -1.282532 */
8989 21577, /* B0 = 0.658508 */
8990 7, /* Internal filter scaling */
8991 159, /* Minimum in-band energy threshold */
8992 21, /* 21/32 in-band to broad-band ratio */
8993 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8994 },
8995 { /* f330_440[] 17 */
8996 30627, /* A1 = 1.869324 */
8997 -31338, /* A2 = -0.95636 */
8998 -843, /* B2 = -0.025749 */
8999 0, /* B1 = 0 */
9000 843, /* B0 = 0.025749 */
9001 30550, /* A1 = 1.864685 */
9002 -32221, /* A2 = -0.983337 */
9003 13594, /* B2 = 0.414886 */
9004 -12589, /* B1 = -0.768402 */
9005 13594, /* B0 = 0.414886 */
9006 31488, /* A1 = 1.921936 */
9007 -32358, /* A2 = -0.987518 */
9008 24684, /* B2 = 0.753296 */
9009 -24029, /* B1 = -1.466614 */
9010 24684, /* B0 = 0.753296 */
9011 7, /* Internal filter scaling */
9012 159, /* Minimum in-band energy threshold */
9013 21, /* 21/32 in-band to broad-band ratio */
9014 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9015 },
9016 { /* f340 18 */
9017 31546, /* A1 = -1.925476 */
9018 -32646, /* A2 = 0.996277 */
9019 -445, /* B2 = -0.013588 */
9020 0, /* B1 = 0.000000 */
9021 445, /* B0 = 0.013588 */
9022 31551, /* A1 = -1.925781 */
9023 -32713, /* A2 = 0.998352 */
9024 23884, /* B2 = 0.728882 */
9025 -22979, /* B1 = -1.402527 */
9026 23884, /* B0 = 0.728882 */
9027 31606, /* A1 = -1.929138 */
9028 -32715, /* A2 = 0.998413 */
9029 863, /* B2 = 0.026367 */
9030 -835, /* B1 = -0.050985 */
9031 863, /* B0 = 0.026367 */
9032 5, /* Internal filter scaling */
9033 159, /* Minimum in-band energy threshold */
9034 21, /* 21/32 in-band to broad-band ratio */
9035 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9036 },
9037 { /* f350_400[] 19 */
9038 31006, /* A1 = 1.892517 */
9039 -32029, /* A2 = -0.977448 */
9040 -461, /* B2 = -0.014096 */
9041 0, /* B1 = 0 */
9042 461, /* B0 = 0.014096 */
9043 30999, /* A1 = 1.892029 */
9044 -32487, /* A2 = -0.991455 */
9045 11325, /* B2 = 0.345612 */
9046 -10682, /* B1 = -0.651978 */
9047 11325, /* B0 = 0.345612 */
9048 31441, /* A1 = 1.919067 */
9049 -32526, /* A2 = -0.992615 */
9050 24324, /* B2 = 0.74231 */
9051 -23535, /* B1 = -1.436523 */
9052 24324, /* B0 = 0.74231 */
9053 7, /* Internal filter scaling */
9054 159, /* Minimum in-band energy threshold */
9055 21, /* 21/32 in-band to broad-band ratio */
9056 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9057 },
9058 { /* f350_440[] */
9059 30634, /* A1 = 1.869751 */
9060 -31533, /* A2 = -0.962341 */
9061 -680, /* B2 = -0.020782 */
9062 0, /* B1 = 0 */
9063 680, /* B0 = 0.020782 */
9064 30571, /* A1 = 1.865906 */
9065 -32277, /* A2 = -0.985016 */
9066 12894, /* B2 = 0.393524 */
9067 -11945, /* B1 = -0.729065 */
9068 12894, /* B0 = 0.393524 */
9069 31367, /* A1 = 1.91449 */
9070 -32379, /* A2 = -0.988129 */
9071 23820, /* B2 = 0.726929 */
9072 -23104, /* B1 = -1.410217 */
9073 23820, /* B0 = 0.726929 */
9074 7, /* Internal filter scaling */
9075 159, /* Minimum in-band energy threshold */
9076 21, /* 21/32 in-band to broad-band ratio */
9077 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9078 },
9079 { /* f350_450[] */
9080 30552, /* A1 = 1.864807 */
9081 -31434, /* A2 = -0.95929 */
9082 -690, /* B2 = -0.021066 */
9083 0, /* B1 = 0 */
9084 690, /* B0 = 0.021066 */
9085 30472, /* A1 = 1.859924 */
9086 -32248, /* A2 = -0.984161 */
9087 13385, /* B2 = 0.408478 */
9088 -12357, /* B1 = -0.754242 */
9089 13385, /* B0 = 0.408478 */
9090 31358, /* A1 = 1.914001 */
9091 -32366, /* A2 = -0.987732 */
9092 26488, /* B2 = 0.80835 */
9093 -25692, /* B1 = -1.568176 */
9094 26490, /* B0 = 0.808411 */
9095 7, /* Internal filter scaling */
9096 159, /* Minimum in-band energy threshold */
9097 21, /* 21/32 in-band to broad-band ratio */
9098 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9099 },
9100 { /* f360 */
9101 31397, /* A1 = -1.916321 */
9102 -32623, /* A2 = 0.995605 */
9103 -117, /* B2 = -0.003598 */
9104 0, /* B1 = 0.000000 */
9105 117, /* B0 = 0.003598 */
9106 31403, /* A1 = -1.916687 */
9107 -32700, /* A2 = 0.997925 */
9108 3388, /* B2 = 0.103401 */
9109 -3240, /* B1 = -0.197784 */
9110 3388, /* B0 = 0.103401 */
9111 31463, /* A1 = -1.920410 */
9112 -32702, /* A2 = 0.997986 */
9113 13346, /* B2 = 0.407288 */
9114 -12863, /* B1 = -0.785126 */
9115 13346, /* B0 = 0.407288 */
9116 5, /* Internal filter scaling */
9117 159, /* Minimum in-band energy threshold */
9118 21, /* 21/32 in-band to broad-band ratio */
9119 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9120 },
9121 { /* f380_420[] */
9122 30831, /* A1 = 1.881775 */
9123 -32064, /* A2 = -0.978546 */
9124 -367, /* B2 = -0.01122 */
9125 0, /* B1 = 0 */
9126 367, /* B0 = 0.01122 */
9127 30813, /* A1 = 1.880737 */
9128 -32456, /* A2 = -0.990509 */
9129 11068, /* B2 = 0.337769 */
9130 -10338, /* B1 = -0.631042 */
9131 11068, /* B0 = 0.337769 */
9132 31214, /* A1 = 1.905212 */
9133 -32491, /* A2 = -0.991577 */
9134 16374, /* B2 = 0.499695 */
9135 -15781, /* B1 = -0.963196 */
9136 16374, /* B0 = 0.499695 */
9137 7, /* Internal filter scaling */
9138 159, /* Minimum in-band energy threshold */
9139 21, /* 21/32 in-band to broad-band ratio */
9140 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9141 },
9142 { /* f392 */
9143 31152, /* A1 = -1.901428 */
9144 -32613, /* A2 = 0.995300 */
9145 -314, /* B2 = -0.009605 */
9146 0, /* B1 = 0.000000 */
9147 314, /* B0 = 0.009605 */
9148 31156, /* A1 = -1.901672 */
9149 -32694, /* A2 = 0.997742 */
9150 28847, /* B2 = 0.880371 */
9151 -2734, /* B1 = -0.166901 */
9152 28847, /* B0 = 0.880371 */
9153 31225, /* A1 = -1.905823 */
9154 -32696, /* A2 = 0.997803 */
9155 462, /* B2 = 0.014108 */
9156 -442, /* B1 = -0.027019 */
9157 462, /* B0 = 0.014108 */
9158 5, /* Internal filter scaling */
9159 159, /* Minimum in-band energy threshold */
9160 21, /* 21/32 in-band to broad-band ratio */
9161 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9162 },
9163 { /* f400_425[] */
9164 30836, /* A1 = 1.882141 */
9165 -32296, /* A2 = -0.985596 */
9166 -324, /* B2 = -0.009903 */
9167 0, /* B1 = 0 */
9168 324, /* B0 = 0.009903 */
9169 30825, /* A1 = 1.881409 */
9170 -32570, /* A2 = -0.993958 */
9171 16847, /* B2 = 0.51416 */
9172 -15792, /* B1 = -0.963898 */
9173 16847, /* B0 = 0.51416 */
9174 31106, /* A1 = 1.89856 */
9175 -32584, /* A2 = -0.994415 */
9176 9579, /* B2 = 0.292328 */
9177 -9164, /* B1 = -0.559357 */
9178 9579, /* B0 = 0.292328 */
9179 7, /* Internal filter scaling */
9180 159, /* Minimum in-band energy threshold */
9181 21, /* 21/32 in-band to broad-band ratio */
9182 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9183 },
9184 { /* f400_440[] */
9185 30702, /* A1 = 1.873962 */
9186 -32134, /* A2 = -0.980682 */
9187 -517, /* B2 = -0.015793 */
9188 0, /* B1 = 0 */
9189 517, /* B0 = 0.015793 */
9190 30676, /* A1 = 1.872375 */
9191 -32520, /* A2 = -0.992462 */
9192 8144, /* B2 = 0.24855 */
9193 -7596, /* B1 = -0.463684 */
9194 8144, /* B0 = 0.24855 */
9195 31084, /* A1 = 1.897217 */
9196 -32547, /* A2 = -0.993256 */
9197 22713, /* B2 = 0.693176 */
9198 -21734, /* B1 = -1.326599 */
9199 22713, /* B0 = 0.693176 */
9200 7, /* Internal filter scaling */
9201 159, /* Minimum in-band energy threshold */
9202 21, /* 21/32 in-band to broad-band ratio */
9203 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9204 },
9205 { /* f400_450[] */
9206 30613, /* A1 = 1.86853 */
9207 -32031, /* A2 = -0.977509 */
9208 -618, /* B2 = -0.018866 */
9209 0, /* B1 = 0 */
9210 618, /* B0 = 0.018866 */
9211 30577, /* A1 = 1.866272 */
9212 -32491, /* A2 = -0.991577 */
9213 9612, /* B2 = 0.293335 */
9214 -8935, /* B1 = -0.54541 */
9215 9612, /* B0 = 0.293335 */
9216 31071, /* A1 = 1.896484 */
9217 -32524, /* A2 = -0.992584 */
9218 21596, /* B2 = 0.659058 */
9219 -20667, /* B1 = -1.261414 */
9220 21596, /* B0 = 0.659058 */
9221 7, /* Internal filter scaling */
9222 159, /* Minimum in-band energy threshold */
9223 21, /* 21/32 in-band to broad-band ratio */
9224 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9225 },
9226 { /* f420 */
9227 30914, /* A1 = -1.886841 */
9228 -32584, /* A2 = 0.994385 */
9229 -426, /* B2 = -0.013020 */
9230 0, /* B1 = 0.000000 */
9231 426, /* B0 = 0.013020 */
9232 30914, /* A1 = -1.886841 */
9233 -32679, /* A2 = 0.997314 */
9234 17520, /* B2 = 0.534668 */
9235 -16471, /* B1 = -1.005310 */
9236 17520, /* B0 = 0.534668 */
9237 31004, /* A1 = -1.892334 */
9238 -32683, /* A2 = 0.997406 */
9239 819, /* B2 = 0.025023 */
9240 -780, /* B1 = -0.047619 */
9241 819, /* B0 = 0.025023 */
9242 5, /* Internal filter scaling */
9243 159, /* Minimum in-band energy threshold */
9244 21, /* 21/32 in-band to broad-band ratio */
9245 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9246 },
9247 #if 0
9248 { /* f425 */
9249 30881, /* A1 = -1.884827 */
9250 -32603, /* A2 = 0.994965 */
9251 -496, /* B2 = -0.015144 */
9252 0, /* B1 = 0.000000 */
9253 496, /* B0 = 0.015144 */
9254 30880, /* A1 = -1.884766 */
9255 -32692, /* A2 = 0.997711 */
9256 24767, /* B2 = 0.755859 */
9257 -23290, /* B1 = -1.421509 */
9258 24767, /* B0 = 0.755859 */
9259 30967, /* A1 = -1.890076 */
9260 -32694, /* A2 = 0.997772 */
9261 728, /* B2 = 0.022232 */
9262 -691, /* B1 = -0.042194 */
9263 728, /* B0 = 0.022232 */
9264 5, /* Internal filter scaling */
9265 159, /* Minimum in-band energy threshold */
9266 21, /* 21/32 in-band to broad-band ratio */
9267 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9268 },
9269 #else
9270 {
9271 30850,
9272 -32534,
9273 -504,
9274 0,
9275 504,
9276 30831,
9277 -32669,
9278 24303,
9279 -22080,
9280 24303,
9281 30994,
9282 -32673,
9283 1905,
9284 -1811,
9285 1905,
9286 5,
9287 129,
9288 17,
9289 0xff5
9290 },
9291 #endif
9292 { /* f425_450[] */
9293 30646, /* A1 = 1.870544 */
9294 -32327, /* A2 = -0.986572 */
9295 -287, /* B2 = -0.008769 */
9296 0, /* B1 = 0 */
9297 287, /* B0 = 0.008769 */
9298 30627, /* A1 = 1.869324 */
9299 -32607, /* A2 = -0.995087 */
9300 13269, /* B2 = 0.404968 */
9301 -12376, /* B1 = -0.755432 */
9302 13269, /* B0 = 0.404968 */
9303 30924, /* A1 = 1.887512 */
9304 -32619, /* A2 = -0.995453 */
9305 19950, /* B2 = 0.608826 */
9306 -18940, /* B1 = -1.156006 */
9307 19950, /* B0 = 0.608826 */
9308 7, /* Internal filter scaling */
9309 159, /* Minimum in-band energy threshold */
9310 21, /* 21/32 in-band to broad-band ratio */
9311 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9312 },
9313 { /* f425_475[] */
9314 30396, /* A1 = 1.855225 */
9315 -32014, /* A2 = -0.97699 */
9316 -395, /* B2 = -0.012055 */
9317 0, /* B1 = 0 */
9318 395, /* B0 = 0.012055 */
9319 30343, /* A1 = 1.85199 */
9320 -32482, /* A2 = -0.991302 */
9321 17823, /* B2 = 0.543945 */
9322 -16431, /* B1 = -1.002869 */
9323 17823, /* B0 = 0.543945 */
9324 30872, /* A1 = 1.884338 */
9325 -32516, /* A2 = -0.99231 */
9326 18124, /* B2 = 0.553101 */
9327 -17246, /* B1 = -1.052673 */
9328 18124, /* B0 = 0.553101 */
9329 7, /* Internal filter scaling */
9330 159, /* Minimum in-band energy threshold */
9331 21, /* 21/32 in-band to broad-band ratio */
9332 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9333 },
9334 { /* f435 */
9335 30796, /* A1 = -1.879639 */
9336 -32603, /* A2 = 0.994965 */
9337 -254, /* B2 = -0.007762 */
9338 0, /* B1 = 0.000000 */
9339 254, /* B0 = 0.007762 */
9340 30793, /* A1 = -1.879456 */
9341 -32692, /* A2 = 0.997711 */
9342 18934, /* B2 = 0.577820 */
9343 -17751, /* B1 = -1.083496 */
9344 18934, /* B0 = 0.577820 */
9345 30882, /* A1 = -1.884888 */
9346 -32694, /* A2 = 0.997772 */
9347 1858, /* B2 = 0.056713 */
9348 -1758, /* B1 = -0.107357 */
9349 1858, /* B0 = 0.056713 */
9350 5, /* Internal filter scaling */
9351 159, /* Minimum in-band energy threshold */
9352 21, /* 21/32 in-band to broad-band ratio */
9353 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9354 },
9355 { /* f440_450[] */
9356 30641, /* A1 = 1.870239 */
9357 -32458, /* A2 = -0.99057 */
9358 -155, /* B2 = -0.004735 */
9359 0, /* B1 = 0 */
9360 155, /* B0 = 0.004735 */
9361 30631, /* A1 = 1.869568 */
9362 -32630, /* A2 = -0.995789 */
9363 11453, /* B2 = 0.349548 */
9364 -10666, /* B1 = -0.651001 */
9365 11453, /* B0 = 0.349548 */
9366 30810, /* A1 = 1.880554 */
9367 -32634, /* A2 = -0.995941 */
9368 12237, /* B2 = 0.373474 */
9369 -11588, /* B1 = -0.707336 */
9370 12237, /* B0 = 0.373474 */
9371 7, /* Internal filter scaling */
9372 159, /* Minimum in-band energy threshold */
9373 21, /* 21/32 in-band to broad-band ratio */
9374 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9375 },
9376 { /* f440_480[] */
9377 30367, /* A1 = 1.853455 */
9378 -32147, /* A2 = -0.981079 */
9379 -495, /* B2 = -0.015113 */
9380 0, /* B1 = 0 */
9381 495, /* B0 = 0.015113 */
9382 30322, /* A1 = 1.850769 */
9383 -32543, /* A2 = -0.993134 */
9384 10031, /* B2 = 0.306152 */
9385 -9252, /* B1 = -0.564728 */
9386 10031, /* B0 = 0.306152 */
9387 30770, /* A1 = 1.878052 */
9388 -32563, /* A2 = -0.993774 */
9389 22674, /* B2 = 0.691956 */
9390 -21465, /* B1 = -1.31012 */
9391 22674, /* B0 = 0.691956 */
9392 7, /* Internal filter scaling */
9393 159, /* Minimum in-band energy threshold */
9394 21, /* 21/32 in-band to broad-band ratio */
9395 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9396 },
9397 { /* f445 */
9398 30709, /* A1 = -1.874329 */
9399 -32603, /* A2 = 0.994965 */
9400 -83, /* B2 = -0.002545 */
9401 0, /* B1 = 0.000000 */
9402 83, /* B0 = 0.002545 */
9403 30704, /* A1 = -1.874084 */
9404 -32692, /* A2 = 0.997711 */
9405 10641, /* B2 = 0.324738 */
9406 -9947, /* B1 = -0.607147 */
9407 10641, /* B0 = 0.324738 */
9408 30796, /* A1 = -1.879639 */
9409 -32694, /* A2 = 0.997772 */
9410 10079, /* B2 = 0.307587 */
9411 9513, /* B1 = 0.580688 */
9412 10079, /* B0 = 0.307587 */
9413 5, /* Internal filter scaling */
9414 159, /* Minimum in-band energy threshold */
9415 21, /* 21/32 in-band to broad-band ratio */
9416 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9417 },
9418 { /* f450 */
9419 30664, /* A1 = -1.871643 */
9420 -32603, /* A2 = 0.994965 */
9421 -164, /* B2 = -0.005029 */
9422 0, /* B1 = 0.000000 */
9423 164, /* B0 = 0.005029 */
9424 30661, /* A1 = -1.871399 */
9425 -32692, /* A2 = 0.997711 */
9426 15294, /* B2 = 0.466736 */
9427 -14275, /* B1 = -0.871307 */
9428 15294, /* B0 = 0.466736 */
9429 30751, /* A1 = -1.876953 */
9430 -32694, /* A2 = 0.997772 */
9431 3548, /* B2 = 0.108284 */
9432 -3344, /* B1 = -0.204155 */
9433 3548, /* B0 = 0.108284 */
9434 5, /* Internal filter scaling */
9435 159, /* Minimum in-band energy threshold */
9436 21, /* 21/32 in-band to broad-band ratio */
9437 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9438 },
9439 { /* f452 */
9440 30653, /* A1 = -1.870911 */
9441 -32615, /* A2 = 0.995361 */
9442 -209, /* B2 = -0.006382 */
9443 0, /* B1 = 0.000000 */
9444 209, /* B0 = 0.006382 */
9445 30647, /* A1 = -1.870605 */
9446 -32702, /* A2 = 0.997986 */
9447 18971, /* B2 = 0.578979 */
9448 -17716, /* B1 = -1.081299 */
9449 18971, /* B0 = 0.578979 */
9450 30738, /* A1 = -1.876099 */
9451 -32702, /* A2 = 0.998016 */
9452 2967, /* B2 = 0.090561 */
9453 -2793, /* B1 = -0.170502 */
9454 2967, /* B0 = 0.090561 */
9455 5, /* Internal filter scaling */
9456 159, /* Minimum in-band energy threshold */
9457 21, /* 21/32 in-band to broad-band ratio */
9458 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9459 },
9460 { /* f475 */
9461 30437, /* A1 = -1.857727 */
9462 -32603, /* A2 = 0.994965 */
9463 -264, /* B2 = -0.008062 */
9464 0, /* B1 = 0.000000 */
9465 264, /* B0 = 0.008062 */
9466 30430, /* A1 = -1.857300 */
9467 -32692, /* A2 = 0.997711 */
9468 21681, /* B2 = 0.661682 */
9469 -20082, /* B1 = -1.225708 */
9470 21681, /* B0 = 0.661682 */
9471 30526, /* A1 = -1.863220 */
9472 -32694, /* A2 = 0.997742 */
9473 1559, /* B2 = 0.047600 */
9474 -1459, /* B1 = -0.089096 */
9475 1559, /* B0 = 0.047600 */
9476 5, /* Internal filter scaling */
9477 159, /* Minimum in-band energy threshold */
9478 21, /* 21/32 in-band to broad-band ratio */
9479 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9480 },
9481 { /* f480_620[] */
9482 28975, /* A1 = 1.768494 */
9483 -30955, /* A2 = -0.944672 */
9484 -1026, /* B2 = -0.03133 */
9485 0, /* B1 = 0 */
9486 1026, /* B0 = 0.03133 */
9487 28613, /* A1 = 1.746399 */
9488 -32089, /* A2 = -0.979309 */
9489 14214, /* B2 = 0.433807 */
9490 -12202, /* B1 = -0.744812 */
9491 14214, /* B0 = 0.433807 */
9492 30243, /* A1 = 1.845947 */
9493 -32238, /* A2 = -0.983856 */
9494 24825, /* B2 = 0.757629 */
9495 -23402, /* B1 = -1.428345 */
9496 24825, /* B0 = 0.757629 */
9497 7, /* Internal filter scaling */
9498 159, /* Minimum in-band energy threshold */
9499 21, /* 21/32 in-band to broad-band ratio */
9500 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9501 },
9502 { /* f494 */
9503 30257, /* A1 = -1.846741 */
9504 -32605, /* A2 = 0.995056 */
9505 -249, /* B2 = -0.007625 */
9506 0, /* B1 = 0.000000 */
9507 249, /* B0 = 0.007625 */
9508 30247, /* A1 = -1.846191 */
9509 -32694, /* A2 = 0.997772 */
9510 18088, /* B2 = 0.552002 */
9511 -16652, /* B1 = -1.016418 */
9512 18088, /* B0 = 0.552002 */
9513 30348, /* A1 = -1.852295 */
9514 -32696, /* A2 = 0.997803 */
9515 2099, /* B2 = 0.064064 */
9516 -1953, /* B1 = -0.119202 */
9517 2099, /* B0 = 0.064064 */
9518 5, /* Internal filter scaling */
9519 159, /* Minimum in-band energy threshold */
9520 21, /* 21/32 in-band to broad-band ratio */
9521 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9522 },
9523 { /* f500 */
9524 30202, /* A1 = -1.843431 */
9525 -32624, /* A2 = 0.995622 */
9526 -413, /* B2 = -0.012622 */
9527 0, /* B1 = 0.000000 */
9528 413, /* B0 = 0.012622 */
9529 30191, /* A1 = -1.842721 */
9530 -32714, /* A2 = 0.998364 */
9531 25954, /* B2 = 0.792057 */
9532 -23890, /* B1 = -1.458131 */
9533 25954, /* B0 = 0.792057 */
9534 30296, /* A1 = -1.849172 */
9535 -32715, /* A2 = 0.998397 */
9536 2007, /* B2 = 0.061264 */
9537 -1860, /* B1 = -0.113568 */
9538 2007, /* B0 = 0.061264 */
9539 5, /* Internal filter scaling */
9540 159, /* Minimum in-band energy threshold */
9541 21, /* 21/32 in-band to broad-band ratio */
9542 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9543 },
9544 { /* f520 */
9545 30001, /* A1 = -1.831116 */
9546 -32613, /* A2 = 0.995270 */
9547 -155, /* B2 = -0.004750 */
9548 0, /* B1 = 0.000000 */
9549 155, /* B0 = 0.004750 */
9550 29985, /* A1 = -1.830200 */
9551 -32710, /* A2 = 0.998260 */
9552 6584, /* B2 = 0.200928 */
9553 -6018, /* B1 = -0.367355 */
9554 6584, /* B0 = 0.200928 */
9555 30105, /* A1 = -1.837524 */
9556 -32712, /* A2 = 0.998291 */
9557 23812, /* B2 = 0.726685 */
9558 -21936, /* B1 = -1.338928 */
9559 23812, /* B0 = 0.726685 */
9560 5, /* Internal filter scaling */
9561 159, /* Minimum in-band energy threshold */
9562 21, /* 21/32 in-band to broad-band ratio */
9563 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9564 },
9565 { /* f523 */
9566 29964, /* A1 = -1.828918 */
9567 -32601, /* A2 = 0.994904 */
9568 -101, /* B2 = -0.003110 */
9569 0, /* B1 = 0.000000 */
9570 101, /* B0 = 0.003110 */
9571 29949, /* A1 = -1.827942 */
9572 -32700, /* A2 = 0.997925 */
9573 11041, /* B2 = 0.336975 */
9574 -10075, /* B1 = -0.614960 */
9575 11041, /* B0 = 0.336975 */
9576 30070, /* A1 = -1.835388 */
9577 -32702, /* A2 = 0.997986 */
9578 16762, /* B2 = 0.511536 */
9579 -15437, /* B1 = -0.942230 */
9580 16762, /* B0 = 0.511536 */
9581 5, /* Internal filter scaling */
9582 159, /* Minimum in-band energy threshold */
9583 21, /* 21/32 in-band to broad-band ratio */
9584 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9585 },
9586 { /* f525 */
9587 29936, /* A1 = -1.827209 */
9588 -32584, /* A2 = 0.994415 */
9589 -91, /* B2 = -0.002806 */
9590 0, /* B1 = 0.000000 */
9591 91, /* B0 = 0.002806 */
9592 29921, /* A1 = -1.826233 */
9593 -32688, /* A2 = 0.997559 */
9594 11449, /* B2 = 0.349396 */
9595 -10426, /* B1 = -0.636383 */
9596 11449, /* B0 = 0.349396 */
9597 30045, /* A1 = -1.833862 */
9598 -32688, /* A2 = 0.997589 */
9599 13055, /* B2 = 0.398407 */
9600 -12028, /* B1 = -0.734161 */
9601 13055, /* B0 = 0.398407 */
9602 5, /* Internal filter scaling */
9603 159, /* Minimum in-band energy threshold */
9604 21, /* 21/32 in-band to broad-band ratio */
9605 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9606 },
9607 { /* f540_660[] */
9608 28499, /* A1 = 1.739441 */
9609 -31129, /* A2 = -0.949982 */
9610 -849, /* B2 = -0.025922 */
9611 0, /* B1 = 0 */
9612 849, /* B0 = 0.025922 */
9613 28128, /* A1 = 1.716797 */
9614 -32130, /* A2 = -0.98056 */
9615 14556, /* B2 = 0.444214 */
9616 -12251, /* B1 = -0.747772 */
9617 14556, /* B0 = 0.444244 */
9618 29667, /* A1 = 1.81073 */
9619 -32244, /* A2 = -0.984039 */
9620 23038, /* B2 = 0.703064 */
9621 -21358, /* B1 = -1.303589 */
9622 23040, /* B0 = 0.703125 */
9623 7, /* Internal filter scaling */
9624 159, /* Minimum in-band energy threshold */
9625 21, /* 21/32 in-band to broad-band ratio */
9626 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9627 },
9628 { /* f587 */
9629 29271, /* A1 = -1.786560 */
9630 -32599, /* A2 = 0.994873 */
9631 -490, /* B2 = -0.014957 */
9632 0, /* B1 = 0.000000 */
9633 490, /* B0 = 0.014957 */
9634 29246, /* A1 = -1.785095 */
9635 -32700, /* A2 = 0.997925 */
9636 28961, /* B2 = 0.883850 */
9637 -25796, /* B1 = -1.574463 */
9638 28961, /* B0 = 0.883850 */
9639 29383, /* A1 = -1.793396 */
9640 -32700, /* A2 = 0.997955 */
9641 1299, /* B2 = 0.039650 */
9642 -1169, /* B1 = -0.071396 */
9643 1299, /* B0 = 0.039650 */
9644 5, /* Internal filter scaling */
9645 159, /* Minimum in-band energy threshold */
9646 21, /* 21/32 in-band to broad-band ratio */
9647 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9648 },
9649 { /* f590 */
9650 29230, /* A1 = -1.784058 */
9651 -32584, /* A2 = 0.994415 */
9652 -418, /* B2 = -0.012757 */
9653 0, /* B1 = 0.000000 */
9654 418, /* B0 = 0.012757 */
9655 29206, /* A1 = -1.782593 */
9656 -32688, /* A2 = 0.997559 */
9657 36556, /* B2 = 1.115601 */
9658 -32478, /* B1 = -1.982300 */
9659 36556, /* B0 = 1.115601 */
9660 29345, /* A1 = -1.791077 */
9661 -32688, /* A2 = 0.997589 */
9662 897, /* B2 = 0.027397 */
9663 -808, /* B1 = -0.049334 */
9664 897, /* B0 = 0.027397 */
9665 5, /* Internal filter scaling */
9666 159, /* Minimum in-band energy threshold */
9667 21, /* 21/32 in-band to broad-band ratio */
9668 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9669 },
9670 { /* f600 */
9671 29116, /* A1 = -1.777100 */
9672 -32603, /* A2 = 0.994965 */
9673 -165, /* B2 = -0.005039 */
9674 0, /* B1 = 0.000000 */
9675 165, /* B0 = 0.005039 */
9676 29089, /* A1 = -1.775452 */
9677 -32708, /* A2 = 0.998199 */
9678 6963, /* B2 = 0.212494 */
9679 -6172, /* B1 = -0.376770 */
9680 6963, /* B0 = 0.212494 */
9681 29237, /* A1 = -1.784485 */
9682 -32710, /* A2 = 0.998230 */
9683 24197, /* B2 = 0.738464 */
9684 -21657, /* B1 = -1.321899 */
9685 24197, /* B0 = 0.738464 */
9686 5, /* Internal filter scaling */
9687 159, /* Minimum in-band energy threshold */
9688 21, /* 21/32 in-band to broad-band ratio */
9689 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9690 },
9691 { /* f660 */
9692 28376, /* A1 = -1.731934 */
9693 -32567, /* A2 = 0.993896 */
9694 -363, /* B2 = -0.011102 */
9695 0, /* B1 = 0.000000 */
9696 363, /* B0 = 0.011102 */
9697 28337, /* A1 = -1.729614 */
9698 -32683, /* A2 = 0.997434 */
9699 21766, /* B2 = 0.664246 */
9700 -18761, /* B1 = -1.145081 */
9701 21766, /* B0 = 0.664246 */
9702 28513, /* A1 = -1.740356 */
9703 -32686, /* A2 = 0.997498 */
9704 2509, /* B2 = 0.076584 */
9705 -2196, /* B1 = -0.134041 */
9706 2509, /* B0 = 0.076584 */
9707 5, /* Internal filter scaling */
9708 159, /* Minimum in-band energy threshold */
9709 21, /* 21/32 in-band to broad-band ratio */
9710 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9711 },
9712 { /* f700 */
9713 27844, /* A1 = -1.699463 */
9714 -32563, /* A2 = 0.993744 */
9715 -366, /* B2 = -0.011187 */
9716 0, /* B1 = 0.000000 */
9717 366, /* B0 = 0.011187 */
9718 27797, /* A1 = -1.696655 */
9719 -32686, /* A2 = 0.997498 */
9720 22748, /* B2 = 0.694214 */
9721 -19235, /* B1 = -1.174072 */
9722 22748, /* B0 = 0.694214 */
9723 27995, /* A1 = -1.708740 */
9724 -32688, /* A2 = 0.997559 */
9725 2964, /* B2 = 0.090477 */
9726 -2546, /* B1 = -0.155449 */
9727 2964, /* B0 = 0.090477 */
9728 5, /* Internal filter scaling */
9729 159, /* Minimum in-band energy threshold */
9730 21, /* 21/32 in-band to broad-band ratio */
9731 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9732 },
9733 { /* f740 */
9734 27297, /* A1 = -1.666077 */
9735 -32551, /* A2 = 0.993408 */
9736 -345, /* B2 = -0.010540 */
9737 0, /* B1 = 0.000000 */
9738 345, /* B0 = 0.010540 */
9739 27240, /* A1 = -1.662598 */
9740 -32683, /* A2 = 0.997406 */
9741 22560, /* B2 = 0.688477 */
9742 -18688, /* B1 = -1.140625 */
9743 22560, /* B0 = 0.688477 */
9744 27461, /* A1 = -1.676147 */
9745 -32684, /* A2 = 0.997467 */
9746 3541, /* B2 = 0.108086 */
9747 -2985, /* B1 = -0.182220 */
9748 3541, /* B0 = 0.108086 */
9749 5, /* Internal filter scaling */
9750 159, /* Minimum in-band energy threshold */
9751 21, /* 21/32 in-band to broad-band ratio */
9752 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9753 },
9754 { /* f750 */
9755 27155, /* A1 = -1.657410 */
9756 -32551, /* A2 = 0.993408 */
9757 -462, /* B2 = -0.014117 */
9758 0, /* B1 = 0.000000 */
9759 462, /* B0 = 0.014117 */
9760 27097, /* A1 = -1.653870 */
9761 -32683, /* A2 = 0.997406 */
9762 32495, /* B2 = 0.991699 */
9763 -26776, /* B1 = -1.634338 */
9764 32495, /* B0 = 0.991699 */
9765 27321, /* A1 = -1.667542 */
9766 -32684, /* A2 = 0.997467 */
9767 1835, /* B2 = 0.056007 */
9768 -1539, /* B1 = -0.093948 */
9769 1835, /* B0 = 0.056007 */
9770 5, /* Internal filter scaling */
9771 159, /* Minimum in-band energy threshold */
9772 21, /* 21/32 in-band to broad-band ratio */
9773 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9774 },
9775 { /* f750_1450[] */
9776 19298, /* A1 = 1.177917 */
9777 -24471, /* A2 = -0.746796 */
9778 -4152, /* B2 = -0.126709 */
9779 0, /* B1 = 0 */
9780 4152, /* B0 = 0.126709 */
9781 12902, /* A1 = 0.787476 */
9782 -29091, /* A2 = -0.887817 */
9783 12491, /* B2 = 0.38121 */
9784 -1794, /* B1 = -0.109528 */
9785 12494, /* B0 = 0.381317 */
9786 26291, /* A1 = 1.604736 */
9787 -30470, /* A2 = -0.929901 */
9788 28859, /* B2 = 0.880737 */
9789 -26084, /* B1 = -1.592102 */
9790 28861, /* B0 = 0.880798 */
9791 7, /* Internal filter scaling */
9792 159, /* Minimum in-band energy threshold */
9793 21, /* 21/32 in-band to broad-band ratio */
9794 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9795 },
9796 { /* f770 */
9797 26867, /* A1 = -1.639832 */
9798 -32551, /* A2 = 0.993408 */
9799 -123, /* B2 = -0.003755 */
9800 0, /* B1 = 0.000000 */
9801 123, /* B0 = 0.003755 */
9802 26805, /* A1 = -1.636108 */
9803 -32683, /* A2 = 0.997406 */
9804 17297, /* B2 = 0.527863 */
9805 -14096, /* B1 = -0.860382 */
9806 17297, /* B0 = 0.527863 */
9807 27034, /* A1 = -1.650085 */
9808 -32684, /* A2 = 0.997467 */
9809 12958, /* B2 = 0.395477 */
9810 -10756, /* B1 = -0.656525 */
9811 12958, /* B0 = 0.395477 */
9812 5, /* Internal filter scaling */
9813 159, /* Minimum in-band energy threshold */
9814 21, /* 21/32 in-band to broad-band ratio */
9815 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9816 },
9817 { /* f800 */
9818 26413, /* A1 = -1.612122 */
9819 -32547, /* A2 = 0.993286 */
9820 -223, /* B2 = -0.006825 */
9821 0, /* B1 = 0.000000 */
9822 223, /* B0 = 0.006825 */
9823 26342, /* A1 = -1.607849 */
9824 -32686, /* A2 = 0.997498 */
9825 6391, /* B2 = 0.195053 */
9826 -5120, /* B1 = -0.312531 */
9827 6391, /* B0 = 0.195053 */
9828 26593, /* A1 = -1.623108 */
9829 -32688, /* A2 = 0.997559 */
9830 23681, /* B2 = 0.722717 */
9831 -19328, /* B1 = -1.179688 */
9832 23681, /* B0 = 0.722717 */
9833 5, /* Internal filter scaling */
9834 159, /* Minimum in-band energy threshold */
9835 21, /* 21/32 in-band to broad-band ratio */
9836 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9837 },
9838 { /* f816 */
9839 26168, /* A1 = -1.597209 */
9840 -32528, /* A2 = 0.992706 */
9841 -235, /* B2 = -0.007182 */
9842 0, /* B1 = 0.000000 */
9843 235, /* B0 = 0.007182 */
9844 26092, /* A1 = -1.592590 */
9845 -32675, /* A2 = 0.997192 */
9846 20823, /* B2 = 0.635498 */
9847 -16510, /* B1 = -1.007751 */
9848 20823, /* B0 = 0.635498 */
9849 26363, /* A1 = -1.609070 */
9850 -32677, /* A2 = 0.997253 */
9851 6739, /* B2 = 0.205688 */
9852 -5459, /* B1 = -0.333206 */
9853 6739, /* B0 = 0.205688 */
9854 5, /* Internal filter scaling */
9855 159, /* Minimum in-band energy threshold */
9856 21, /* 21/32 in-band to broad-band ratio */
9857 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9858 },
9859 { /* f850 */
9860 25641, /* A1 = -1.565063 */
9861 -32536, /* A2 = 0.992950 */
9862 -121, /* B2 = -0.003707 */
9863 0, /* B1 = 0.000000 */
9864 121, /* B0 = 0.003707 */
9865 25560, /* A1 = -1.560059 */
9866 -32684, /* A2 = 0.997437 */
9867 18341, /* B2 = 0.559753 */
9868 -14252, /* B1 = -0.869904 */
9869 18341, /* B0 = 0.559753 */
9870 25837, /* A1 = -1.577026 */
9871 -32684, /* A2 = 0.997467 */
9872 16679, /* B2 = 0.509003 */
9873 -13232, /* B1 = -0.807648 */
9874 16679, /* B0 = 0.509003 */
9875 5, /* Internal filter scaling */
9876 159, /* Minimum in-band energy threshold */
9877 21, /* 21/32 in-band to broad-band ratio */
9878 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9879 },
9880 { /* f857_1645[] */
9881 16415, /* A1 = 1.001953 */
9882 -23669, /* A2 = -0.722321 */
9883 -4549, /* B2 = -0.138847 */
9884 0, /* B1 = 0 */
9885 4549, /* B0 = 0.138847 */
9886 8456, /* A1 = 0.516174 */
9887 -28996, /* A2 = -0.884918 */
9888 13753, /* B2 = 0.419724 */
9889 -12, /* B1 = -0.000763 */
9890 13757, /* B0 = 0.419846 */
9891 24632, /* A1 = 1.503418 */
9892 -30271, /* A2 = -0.923828 */
9893 29070, /* B2 = 0.887146 */
9894 -25265, /* B1 = -1.542114 */
9895 29073, /* B0 = 0.887268 */
9896 7, /* Internal filter scaling */
9897 159, /* Minimum in-band energy threshold */
9898 21, /* 21/32 in-band to broad-band ratio */
9899 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9900 },
9901 { /* f900 */
9902 24806, /* A1 = -1.514099 */
9903 -32501, /* A2 = 0.991852 */
9904 -326, /* B2 = -0.009969 */
9905 0, /* B1 = 0.000000 */
9906 326, /* B0 = 0.009969 */
9907 24709, /* A1 = -1.508118 */
9908 -32659, /* A2 = 0.996674 */
9909 20277, /* B2 = 0.618835 */
9910 -15182, /* B1 = -0.926636 */
9911 20277, /* B0 = 0.618835 */
9912 25022, /* A1 = -1.527222 */
9913 -32661, /* A2 = 0.996735 */
9914 4320, /* B2 = 0.131836 */
9915 -3331, /* B1 = -0.203339 */
9916 4320, /* B0 = 0.131836 */
9917 5, /* Internal filter scaling */
9918 159, /* Minimum in-band energy threshold */
9919 21, /* 21/32 in-band to broad-band ratio */
9920 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9921 },
9922 { /* f900_1300[] */
9923 19776, /* A1 = 1.207092 */
9924 -27437, /* A2 = -0.837341 */
9925 -2666, /* B2 = -0.081371 */
9926 0, /* B1 = 0 */
9927 2666, /* B0 = 0.081371 */
9928 16302, /* A1 = 0.995026 */
9929 -30354, /* A2 = -0.926361 */
9930 10389, /* B2 = 0.317062 */
9931 -3327, /* B1 = -0.203064 */
9932 10389, /* B0 = 0.317062 */
9933 24299, /* A1 = 1.483154 */
9934 -30930, /* A2 = -0.943909 */
9935 25016, /* B2 = 0.763428 */
9936 -21171, /* B1 = -1.292236 */
9937 25016, /* B0 = 0.763428 */
9938 7, /* Internal filter scaling */
9939 159, /* Minimum in-band energy threshold */
9940 21, /* 21/32 in-band to broad-band ratio */
9941 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9942 },
9943 { /* f935_1215[] */
9944 20554, /* A1 = 1.254517 */
9945 -28764, /* A2 = -0.877838 */
9946 -2048, /* B2 = -0.062515 */
9947 0, /* B1 = 0 */
9948 2048, /* B0 = 0.062515 */
9949 18209, /* A1 = 1.11145 */
9950 -30951, /* A2 = -0.94458 */
9951 9390, /* B2 = 0.286575 */
9952 -3955, /* B1 = -0.241455 */
9953 9390, /* B0 = 0.286575 */
9954 23902, /* A1 = 1.458923 */
9955 -31286, /* A2 = -0.954803 */
9956 23252, /* B2 = 0.709595 */
9957 -19132, /* B1 = -1.167725 */
9958 23252, /* B0 = 0.709595 */
9959 7, /* Internal filter scaling */
9960 159, /* Minimum in-band energy threshold */
9961 21, /* 21/32 in-band to broad-band ratio */
9962 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9963 },
9964 { /* f941_1477[] */
9965 17543, /* A1 = 1.07074 */
9966 -26220, /* A2 = -0.800201 */
9967 -3298, /* B2 = -0.100647 */
9968 0, /* B1 = 0 */
9969 3298, /* B0 = 0.100647 */
9970 12423, /* A1 = 0.75827 */
9971 -30036, /* A2 = -0.916626 */
9972 12651, /* B2 = 0.386078 */
9973 -2444, /* B1 = -0.14917 */
9974 12653, /* B0 = 0.386154 */
9975 23518, /* A1 = 1.435425 */
9976 -30745, /* A2 = -0.938293 */
9977 27282, /* B2 = 0.832581 */
9978 -22529, /* B1 = -1.375122 */
9979 27286, /* B0 = 0.832703 */
9980 7, /* Internal filter scaling */
9981 159, /* Minimum in-band energy threshold */
9982 21, /* 21/32 in-band to broad-band ratio */
9983 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9984 },
9985 { /* f942 */
9986 24104, /* A1 = -1.471252 */
9987 -32507, /* A2 = 0.992065 */
9988 -351, /* B2 = -0.010722 */
9989 0, /* B1 = 0.000000 */
9990 351, /* B0 = 0.010722 */
9991 23996, /* A1 = -1.464600 */
9992 -32671, /* A2 = 0.997040 */
9993 22848, /* B2 = 0.697266 */
9994 -16639, /* B1 = -1.015564 */
9995 22848, /* B0 = 0.697266 */
9996 24332, /* A1 = -1.485168 */
9997 -32673, /* A2 = 0.997101 */
9998 4906, /* B2 = 0.149727 */
9999 -3672, /* B1 = -0.224174 */
10000 4906, /* B0 = 0.149727 */
10001 5, /* Internal filter scaling */
10002 159, /* Minimum in-band energy threshold */
10003 21, /* 21/32 in-band to broad-band ratio */
10004 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10005 },
10006 { /* f950 */
10007 23967, /* A1 = -1.462830 */
10008 -32507, /* A2 = 0.992065 */
10009 -518, /* B2 = -0.015821 */
10010 0, /* B1 = 0.000000 */
10011 518, /* B0 = 0.015821 */
10012 23856, /* A1 = -1.456055 */
10013 -32671, /* A2 = 0.997040 */
10014 26287, /* B2 = 0.802246 */
10015 -19031, /* B1 = -1.161560 */
10016 26287, /* B0 = 0.802246 */
10017 24195, /* A1 = -1.476746 */
10018 -32673, /* A2 = 0.997101 */
10019 2890, /* B2 = 0.088196 */
10020 -2151, /* B1 = -0.131317 */
10021 2890, /* B0 = 0.088196 */
10022 5, /* Internal filter scaling */
10023 159, /* Minimum in-band energy threshold */
10024 21, /* 21/32 in-band to broad-band ratio */
10025 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10026 },
10027 { /* f950_1400[] */
10028 18294, /* A1 = 1.116638 */
10029 -26962, /* A2 = -0.822845 */
10030 -2914, /* B2 = -0.088936 */
10031 0, /* B1 = 0 */
10032 2914, /* B0 = 0.088936 */
10033 14119, /* A1 = 0.861786 */
10034 -30227, /* A2 = -0.922455 */
10035 11466, /* B2 = 0.349945 */
10036 -2833, /* B1 = -0.172943 */
10037 11466, /* B0 = 0.349945 */
10038 23431, /* A1 = 1.430115 */
10039 -30828, /* A2 = -0.940796 */
10040 25331, /* B2 = 0.773071 */
10041 -20911, /* B1 = -1.276367 */
10042 25331, /* B0 = 0.773071 */
10043 7, /* Internal filter scaling */
10044 159, /* Minimum in-band energy threshold */
10045 21, /* 21/32 in-band to broad-band ratio */
10046 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10047 },
10048 { /* f975 */
10049 23521, /* A1 = -1.435608 */
10050 -32489, /* A2 = 0.991516 */
10051 -193, /* B2 = -0.005915 */
10052 0, /* B1 = 0.000000 */
10053 193, /* B0 = 0.005915 */
10054 23404, /* A1 = -1.428467 */
10055 -32655, /* A2 = 0.996582 */
10056 17740, /* B2 = 0.541412 */
10057 -12567, /* B1 = -0.767029 */
10058 17740, /* B0 = 0.541412 */
10059 23753, /* A1 = -1.449829 */
10060 -32657, /* A2 = 0.996613 */
10061 9090, /* B2 = 0.277405 */
10062 -6662, /* B1 = -0.406647 */
10063 9090, /* B0 = 0.277405 */
10064 5, /* Internal filter scaling */
10065 159, /* Minimum in-band energy threshold */
10066 21, /* 21/32 in-band to broad-band ratio */
10067 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10068 },
10069 { /* f1000 */
10070 23071, /* A1 = -1.408203 */
10071 -32489, /* A2 = 0.991516 */
10072 -293, /* B2 = -0.008965 */
10073 0, /* B1 = 0.000000 */
10074 293, /* B0 = 0.008965 */
10075 22951, /* A1 = -1.400818 */
10076 -32655, /* A2 = 0.996582 */
10077 5689, /* B2 = 0.173645 */
10078 -3951, /* B1 = -0.241150 */
10079 5689, /* B0 = 0.173645 */
10080 23307, /* A1 = -1.422607 */
10081 -32657, /* A2 = 0.996613 */
10082 18692, /* B2 = 0.570435 */
10083 -13447, /* B1 = -0.820770 */
10084 18692, /* B0 = 0.570435 */
10085 5, /* Internal filter scaling */
10086 159, /* Minimum in-band energy threshold */
10087 21, /* 21/32 in-band to broad-band ratio */
10088 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10089 },
10090 { /* f1020 */
10091 22701, /* A1 = -1.385620 */
10092 -32474, /* A2 = 0.991058 */
10093 -292, /* B2 = -0.008933 */
10094 0, /*163840 , B1 = 10.000000 */
10095 292, /* B0 = 0.008933 */
10096 22564, /* A1 = -1.377258 */
10097 -32655, /* A2 = 0.996552 */
10098 20756, /* B2 = 0.633423 */
10099 -14176, /* B1 = -0.865295 */
10100 20756, /* B0 = 0.633423 */
10101 22960, /* A1 = -1.401428 */
10102 -32657, /* A2 = 0.996613 */
10103 6520, /* B2 = 0.198990 */
10104 -4619, /* B1 = -0.281937 */
10105 6520, /* B0 = 0.198990 */
10106 5, /* Internal filter scaling */
10107 159, /* Minimum in-band energy threshold */
10108 21, /* 21/32 in-band to broad-band ratio */
10109 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10110 },
10111 { /* f1050 */
10112 22142, /* A1 = -1.351501 */
10113 -32474, /* A2 = 0.991058 */
10114 -147, /* B2 = -0.004493 */
10115 0, /* B1 = 0.000000 */
10116 147, /* B0 = 0.004493 */
10117 22000, /* A1 = -1.342834 */
10118 -32655, /* A2 = 0.996552 */
10119 15379, /* B2 = 0.469360 */
10120 -10237, /* B1 = -0.624847 */
10121 15379, /* B0 = 0.469360 */
10122 22406, /* A1 = -1.367554 */
10123 -32657, /* A2 = 0.996613 */
10124 17491, /* B2 = 0.533783 */
10125 -12096, /* B1 = -0.738312 */
10126 17491, /* B0 = 0.533783 */
10127 5, /* Internal filter scaling */
10128 159, /* Minimum in-band energy threshold */
10129 21, /* 21/32 in-band to broad-band ratio */
10130 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10131 },
10132 { /* f1100_1750[] */
10133 12973, /* A1 = 0.79184 */
10134 -24916, /* A2 = -0.760376 */
10135 6655, /* B2 = 0.203102 */
10136 367, /* B1 = 0.0224 */
10137 6657, /* B0 = 0.203171 */
10138 5915, /* A1 = 0.361053 */
10139 -29560, /* A2 = -0.90213 */
10140 -7777, /* B2 = -0.23735 */
10141 0, /* B1 = 0 */
10142 7777, /* B0 = 0.23735 */
10143 20510, /* A1 = 1.251892 */
10144 -30260, /* A2 = -0.923462 */
10145 26662, /* B2 = 0.81366 */
10146 -20573, /* B1 = -1.255737 */
10147 26668, /* B0 = 0.813843 */
10148 7, /* Internal filter scaling */
10149 159, /* Minimum in-band energy threshold */
10150 21, /* 21/32 in-band to broad-band ratio */
10151 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10152 },
10153 { /* f1140 */
10154 20392, /* A1 = -1.244629 */
10155 -32460, /* A2 = 0.990601 */
10156 -270, /* B2 = -0.008240 */
10157 0, /* B1 = 0.000000 */
10158 270, /* B0 = 0.008240 */
10159 20218, /* A1 = -1.234009 */
10160 -32655, /* A2 = 0.996582 */
10161 21337, /* B2 = 0.651154 */
10162 -13044, /* B1 = -0.796143 */
10163 21337, /* B0 = 0.651154 */
10164 20684, /* A1 = -1.262512 */
10165 -32657, /* A2 = 0.996643 */
10166 8572, /* B2 = 0.261612 */
10167 -5476, /* B1 = -0.334244 */
10168 8572, /* B0 = 0.261612 */
10169 5, /* Internal filter scaling */
10170 159, /* Minimum in-band energy threshold */
10171 21, /* 21/32 in-band to broad-band ratio */
10172 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10173 },
10174 { /* f1200 */
10175 19159, /* A1 = -1.169373 */
10176 -32456, /* A2 = 0.990509 */
10177 -335, /* B2 = -0.010252 */
10178 0, /* B1 = 0.000000 */
10179 335, /* B0 = 0.010252 */
10180 18966, /* A1 = -1.157593 */
10181 -32661, /* A2 = 0.996735 */
10182 6802, /* B2 = 0.207588 */
10183 -3900, /* B1 = -0.238098 */
10184 6802, /* B0 = 0.207588 */
10185 19467, /* A1 = -1.188232 */
10186 -32661, /* A2 = 0.996765 */
10187 25035, /* B2 = 0.764008 */
10188 -15049, /* B1 = -0.918579 */
10189 25035, /* B0 = 0.764008 */
10190 5, /* Internal filter scaling */
10191 159, /* Minimum in-band energy threshold */
10192 21, /* 21/32 in-band to broad-band ratio */
10193 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10194 },
10195 { /* f1209 */
10196 18976, /* A1 = -1.158264 */
10197 -32439, /* A2 = 0.989990 */
10198 -183, /* B2 = -0.005588 */
10199 0, /* B1 = 0.000000 */
10200 183, /* B0 = 0.005588 */
10201 18774, /* A1 = -1.145874 */
10202 -32650, /* A2 = 0.996429 */
10203 15468, /* B2 = 0.472076 */
10204 -8768, /* B1 = -0.535217 */
10205 15468, /* B0 = 0.472076 */
10206 19300, /* A1 = -1.177979 */
10207 -32652, /* A2 = 0.996490 */
10208 19840, /* B2 = 0.605499 */
10209 -11842, /* B1 = -0.722809 */
10210 19840, /* B0 = 0.605499 */
10211 5, /* Internal filter scaling */
10212 159, /* Minimum in-band energy threshold */
10213 21, /* 21/32 in-band to broad-band ratio */
10214 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10215 },
10216 { /* f1330 */
10217 16357, /* A1 = -0.998413 */
10218 -32368, /* A2 = 0.987793 */
10219 -217, /* B2 = -0.006652 */
10220 0, /* B1 = 0.000000 */
10221 217, /* B0 = 0.006652 */
10222 16107, /* A1 = -0.983126 */
10223 -32601, /* A2 = 0.994904 */
10224 11602, /* B2 = 0.354065 */
10225 -5555, /* B1 = -0.339111 */
10226 11602, /* B0 = 0.354065 */
10227 16722, /* A1 = -1.020630 */
10228 -32603, /* A2 = 0.994965 */
10229 15574, /* B2 = 0.475311 */
10230 -8176, /* B1 = -0.499069 */
10231 15574, /* B0 = 0.475311 */
10232 5, /* Internal filter scaling */
10233 159, /* Minimum in-band energy threshold */
10234 21, /* 21/32 in-band to broad-band ratio */
10235 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10236 },
10237 { /* f1336 */
10238 16234, /* A1 = -0.990875 */
10239 32404, /* A2 = -0.988922 */
10240 -193, /* B2 = -0.005908 */
10241 0, /* B1 = 0.000000 */
10242 193, /* B0 = 0.005908 */
10243 15986, /* A1 = -0.975769 */
10244 -32632, /* A2 = 0.995880 */
10245 18051, /* B2 = 0.550903 */
10246 -8658, /* B1 = -0.528473 */
10247 18051, /* B0 = 0.550903 */
10248 16591, /* A1 = -1.012695 */
10249 -32634, /* A2 = 0.995941 */
10250 15736, /* B2 = 0.480240 */
10251 -8125, /* B1 = -0.495926 */
10252 15736, /* B0 = 0.480240 */
10253 5, /* Internal filter scaling */
10254 159, /* Minimum in-band energy threshold */
10255 21, /* 21/32 in-band to broad-band ratio */
10256 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10257 },
10258 { /* f1366 */
10259 15564, /* A1 = -0.949982 */
10260 -32404, /* A2 = 0.988922 */
10261 -269, /* B2 = -0.008216 */
10262 0, /* B1 = 0.000000 */
10263 269, /* B0 = 0.008216 */
10264 15310, /* A1 = -0.934479 */
10265 -32632, /* A2 = 0.995880 */
10266 10815, /* B2 = 0.330063 */
10267 -4962, /* B1 = -0.302887 */
10268 10815, /* B0 = 0.330063 */
10269 15924, /* A1 = -0.971924 */
10270 -32634, /* A2 = 0.995941 */
10271 18880, /* B2 = 0.576172 */
10272 -9364, /* B1 = -0.571594 */
10273 18880, /* B0 = 0.576172 */
10274 5, /* Internal filter scaling */
10275 159, /* Minimum in-band energy threshold */
10276 21, /* 21/32 in-band to broad-band ratio */
10277 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10278 },
10279 { /* f1380 */
10280 15247, /* A1 = -0.930603 */
10281 -32397, /* A2 = 0.988708 */
10282 -244, /* B2 = -0.007451 */
10283 0, /* B1 = 0.000000 */
10284 244, /* B0 = 0.007451 */
10285 14989, /* A1 = -0.914886 */
10286 -32627, /* A2 = 0.995697 */
10287 18961, /* B2 = 0.578644 */
10288 -8498, /* B1 = -0.518707 */
10289 18961, /* B0 = 0.578644 */
10290 15608, /* A1 = -0.952667 */
10291 -32628, /* A2 = 0.995758 */
10292 11145, /* B2 = 0.340134 */
10293 -5430, /* B1 = -0.331467 */
10294 11145, /* B0 = 0.340134 */
10295 5, /* Internal filter scaling */
10296 159, /* Minimum in-band energy threshold */
10297 21, /* 21/32 in-band to broad-band ratio */
10298 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10299 },
10300 { /* f1400 */
10301 14780, /* A1 = -0.902130 */
10302 -32393, /* A2 = 0.988586 */
10303 -396, /* B2 = -0.012086 */
10304 0, /* B1 = 0.000000 */
10305 396, /* B0 = 0.012086 */
10306 14510, /* A1 = -0.885651 */
10307 -32630, /* A2 = 0.995819 */
10308 6326, /* B2 = 0.193069 */
10309 -2747, /* B1 = -0.167671 */
10310 6326, /* B0 = 0.193069 */
10311 15154, /* A1 = -0.924957 */
10312 -32632, /* A2 = 0.995850 */
10313 23235, /* B2 = 0.709076 */
10314 -10983, /* B1 = -0.670380 */
10315 23235, /* B0 = 0.709076 */
10316 5, /* Internal filter scaling */
10317 159, /* Minimum in-band energy threshold */
10318 21, /* 21/32 in-band to broad-band ratio */
10319 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10320 },
10321 { /* f1477 */
10322 13005, /* A1 = -0.793793 */
10323 -32368, /* A2 = 0.987823 */
10324 -500, /* B2 = -0.015265 */
10325 0, /* B1 = 0.000000 */
10326 500, /* B0 = 0.015265 */
10327 12708, /* A1 = -0.775665 */
10328 -32615, /* A2 = 0.995331 */
10329 11420, /* B2 = 0.348526 */
10330 -4306, /* B1 = -0.262833 */
10331 11420, /* B0 = 0.348526 */
10332 13397, /* A1 = -0.817688 */
10333 -32615, /* A2 = 0.995361 */
10334 9454, /* B2 = 0.288528 */
10335 -3981, /* B1 = -0.243027 */
10336 9454, /* B0 = 0.288528 */
10337 5, /* Internal filter scaling */
10338 159, /* Minimum in-band energy threshold */
10339 21, /* 21/32 in-band to broad-band ratio */
10340 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10341 },
10342 { /* f1600 */
10343 10046, /* A1 = -0.613190 */
10344 -32331, /* A2 = 0.986694 */
10345 -455, /* B2 = -0.013915 */
10346 0, /* B1 = 0.000000 */
10347 455, /* B0 = 0.013915 */
10348 9694, /* A1 = -0.591705 */
10349 -32601, /* A2 = 0.994934 */
10350 6023, /* B2 = 0.183815 */
10351 -1708, /* B1 = -0.104279 */
10352 6023, /* B0 = 0.183815 */
10353 10478, /* A1 = -0.639587 */
10354 -32603, /* A2 = 0.994965 */
10355 22031, /* B2 = 0.672333 */
10356 -7342, /* B1 = -0.448151 */
10357 22031, /* B0 = 0.672333 */
10358 5, /* Internal filter scaling */
10359 159, /* Minimum in-band energy threshold */
10360 21, /* 21/32 in-band to broad-band ratio */
10361 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10362 },
10363 { /* f1633_1638[] */
10364 9181, /* A1 = 0.560394 */
10365 -32256, /* A2 = -0.984375 */
10366 -556, /* B2 = -0.016975 */
10367 0, /* B1 = 0 */
10368 556, /* B0 = 0.016975 */
10369 8757, /* A1 = 0.534515 */
10370 -32574, /* A2 = -0.99408 */
10371 8443, /* B2 = 0.25769 */
10372 -2135, /* B1 = -0.130341 */
10373 8443, /* B0 = 0.25769 */
10374 9691, /* A1 = 0.591522 */
10375 -32574, /* A2 = -0.99411 */
10376 15446, /* B2 = 0.471375 */
10377 -4809, /* B1 = -0.293579 */
10378 15446, /* B0 = 0.471375 */
10379 7, /* Internal filter scaling */
10380 159, /* Minimum in-band energy threshold */
10381 21, /* 21/32 in-band to broad-band ratio */
10382 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10383 },
10384 { /* f1800 */
10385 5076, /* A1 = -0.309875 */
10386 -32304, /* A2 = 0.985840 */
10387 -508, /* B2 = -0.015503 */
10388 0, /* B1 = 0.000000 */
10389 508, /* B0 = 0.015503 */
10390 4646, /* A1 = -0.283600 */
10391 -32605, /* A2 = 0.995026 */
10392 6742, /* B2 = 0.205780 */
10393 -878, /* B1 = -0.053635 */
10394 6742, /* B0 = 0.205780 */
10395 5552, /* A1 = -0.338928 */
10396 -32605, /* A2 = 0.995056 */
10397 23667, /* B2 = 0.722260 */
10398 -4297, /* B1 = -0.262329 */
10399 23667, /* B0 = 0.722260 */
10400 5, /* Internal filter scaling */
10401 159, /* Minimum in-band energy threshold */
10402 21, /* 21/32 in-band to broad-band ratio */
10403 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10404 },
10405 { /* f1860 */
10406 3569, /* A1 = -0.217865 */
10407 -32292, /* A2 = 0.985504 */
10408 -239, /* B2 = -0.007322 */
10409 0, /* B1 = 0.000000 */
10410 239, /* B0 = 0.007322 */
10411 3117, /* A1 = -0.190277 */
10412 -32603, /* A2 = 0.994965 */
10413 18658, /* B2 = 0.569427 */
10414 -1557, /* B1 = -0.095032 */
10415 18658, /* B0 = 0.569427 */
10416 4054, /* A1 = -0.247437 */
10417 -32603, /* A2 = 0.994965 */
10418 18886, /* B2 = 0.576385 */
10419 -2566, /* B1 = -0.156647 */
10420 18886, /* B0 = 0.576385 */
10421 5, /* Internal filter scaling */
10422 159, /* Minimum in-band energy threshold */
10423 21, /* 21/32 in-band to broad-band ratio */
10424 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10425 },
10426 };
10427 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10428 {
10429 unsigned short cmd;
10430 int cnt, max;
10431
10432 if (jf->filter > 3) {
10433 return -1;
10434 }
10435 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10436
10437 return -1;
10438 if (!jf->enable) {
10439 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10440
10441 return -1;
10442 else
10443 return 0;
10444 } else {
10445 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10446
10447 return -1;
10448 /* Select the filter (f0 - f3) to use. */
10449 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10450 return -1;
10451 }
10452 if (jf->freq < 12 && jf->freq > 3) {
10453 /* Select the frequency for the selected filter. */
10454 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10455 return -1;
10456 } else if (jf->freq > 11) {
10457 /* We need to load a programmable filter set for undefined */
10458 /* frequencies. So we will point the filter to a programmable set. */
10459 /* Since there are only 4 filters and 4 programmable sets, we will */
10460 /* just point the filter to the same number set and program it for the */
10461 /* frequency we want. */
10462 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10463 return -1;
10464 if (j->ver.low != 0x12) {
10465 cmd = 0x515B;
10466 max = 19;
10467 } else {
10468 cmd = 0x515E;
10469 max = 15;
10470 }
10471 if (ixj_WriteDSPCommand(cmd, j))
10472 return -1;
10473 for (cnt = 0; cnt < max; cnt++) {
10474 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10475 return -1;
10476 }
10477 }
10478 j->filter_en[jf->filter] = jf->enable;
10479 return 0;
10480 }
10481
10482 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10483 {
10484 unsigned short cmd;
10485 int cnt, max;
10486 if (jfr->filter > 3) {
10487 return -1;
10488 }
10489 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10490 return -1;
10491
10492 if (!jfr->enable) {
10493 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10494 return -1;
10495 else
10496 return 0;
10497 } else {
10498 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10499 return -1;
10500 /* Select the filter (f0 - f3) to use. */
10501 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10502 return -1;
10503 }
10504 /* We need to load a programmable filter set for undefined */
10505 /* frequencies. So we will point the filter to a programmable set. */
10506 /* Since there are only 4 filters and 4 programmable sets, we will */
10507 /* just point the filter to the same number set and program it for the */
10508 /* frequency we want. */
10509 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10510 return -1;
10511 if (j->ver.low != 0x12) {
10512 cmd = 0x515B;
10513 max = 19;
10514 } else {
10515 cmd = 0x515E;
10516 max = 15;
10517 }
10518 if (ixj_WriteDSPCommand(cmd, j))
10519 return -1;
10520 for (cnt = 0; cnt < max; cnt++) {
10521 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10522 return -1;
10523 }
10524 j->filter_en[jfr->filter] = jfr->enable;
10525 return 0;
10526 }
10527
10528 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10529 {
10530 int freq0, freq1;
10531 unsigned short data;
10532 if (ti->freq0) {
10533 freq0 = ti->freq0;
10534 } else {
10535 freq0 = 0x7FFF;
10536 }
10537
10538 if (ti->freq1) {
10539 freq1 = ti->freq1;
10540 } else {
10541 freq1 = 0x7FFF;
10542 }
10543
10544 if(ti->tone_index > 12 && ti->tone_index < 28)
10545 {
10546 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10547 return -1;
10548 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10549 return -1;
10550 data = freq0;
10551 if (ixj_WriteDSPCommand(data, j))
10552 return -1;
10553 data = freq1;
10554 if (ixj_WriteDSPCommand(data, j))
10555 return -1;
10556 }
10557 return freq0;
10558 }
10559
Linux kernel - Deliverables
This page took 0.297674 seconds and 5 git commands to generate.