?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / telephony / ixj.c
blobf2c9fa423d402d1262b6af64e3d3180c567f39cf
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * $Log: ixj.c,v $
46 *
47 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
48 * Audit some copy_*_user and minor cleanup.
49 *
50 * Revision 4.7 2001/08/13 06:19:33 craigs
51 * Added additional changes from Alan Cox and John Anderson for
52 * 2.2 to 2.4 cleanup and bounds checking
53 *
54 * Revision 4.6 2001/08/13 01:05:05 craigs
55 * Really fixed PHONE_QUERY_CODEC problem this time
56 *
57 * Revision 4.5 2001/08/13 00:11:03 craigs
58 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
59 *
60 * Revision 4.4 2001/08/07 07:58:12 craigs
61 * Changed back to three digit version numbers
62 * Added tagbuild target to allow automatic and easy tagging of versions
63 *
64 * Revision 4.3 2001/08/07 07:24:47 craigs
65 * Added ixj-ver.h to allow easy configuration management of driver
66 * Added display of version number in /prox/ixj
67 *
68 * Revision 4.2 2001/08/06 07:07:19 craigs
69 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
70 * behaviour of returning int rather than short *
71 *
72 * Revision 4.1 2001/08/05 00:17:37 craigs
73 * More changes for correct PCMCIA installation
74 * Start of changes for backward Linux compatibility
75 *
76 * Revision 4.0 2001/08/04 12:33:12 craigs
77 * New version using GNU autoconf
78 *
79 * Revision 3.105 2001/07/20 23:14:32 eokerson
80 * More work on CallerID generation when using ring cadences.
81 *
82 * Revision 3.104 2001/07/06 01:33:55 eokerson
83 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
84 *
85 * Revision 3.103 2001/07/05 19:20:16 eokerson
86 * Updated HOWTO
87 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
88 *
89 * Revision 3.102 2001/07/03 23:51:21 eokerson
90 * Un-mute mic on Internet LineJACK when in speakerphone mode.
91 *
92 * Revision 3.101 2001/07/02 19:26:56 eokerson
93 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
94 *
95 * Revision 3.100 2001/07/02 19:18:27 eokerson
96 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
97 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
98 * Fixed speaker mode on Internet LineJACK.
99 *
100 * Revision 3.99 2001/05/09 14:11:16 eokerson
101 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
102 *
103 * Revision 3.98 2001/05/08 19:55:33 eokerson
104 * Fixed POTS hookstate detection while it is connected to PSTN port.
105 *
106 * Revision 3.97 2001/05/08 00:01:04 eokerson
107 * Fixed kernel oops when sending caller ID data.
108 *
109 * Revision 3.96 2001/05/04 23:09:30 eokerson
110 * Now uses one kernel timer for each card, instead of one for the entire driver.
111 *
112 * Revision 3.95 2001/04/25 22:06:47 eokerson
113 * Fixed squawking at beginning of some G.723.1 calls.
114 *
115 * Revision 3.94 2001/04/03 23:42:00 eokerson
116 * Added linear volume ioctls
117 * Added raw filter load ioctl
118 *
119 * Revision 3.93 2001/02/27 01:00:06 eokerson
120 * Fixed blocking in CallerID.
121 * Reduced size of ixj structure for smaller driver footprint.
122 *
123 * Revision 3.92 2001/02/20 22:02:59 eokerson
124 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
125 * Improved PSTN ring detection.
126 * Fixed wink generation on POTS ports.
127 *
128 * Revision 3.91 2001/02/13 00:55:44 eokerson
129 * Turn AEC back on after changing frame sizes.
130 *
131 * Revision 3.90 2001/02/12 16:42:00 eokerson
132 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
133 *
134 * Revision 3.89 2001/02/12 15:41:16 eokerson
135 * Fix from Artis Kugevics - Tone gains were not being set correctly.
136 *
137 * Revision 3.88 2001/02/05 23:25:42 eokerson
138 * Fixed lockup bugs with deregister.
139 *
140 * Revision 3.87 2001/01/29 21:00:39 eokerson
141 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
142 * Updated copyright date.
143 *
144 * Revision 3.86 2001/01/23 23:53:46 eokerson
145 * Fixes to G.729 compatibility.
146 *
147 * Revision 3.85 2001/01/23 21:30:36 eokerson
148 * Added verbage about cards supported.
149 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
150 *
151 * Revision 3.84 2001/01/22 23:32:10 eokerson
152 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
153 *
154 * Revision 3.83 2001/01/19 14:51:41 eokerson
155 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
156 *
157 * Revision 3.82 2001/01/19 00:34:49 eokerson
158 * Added verbosity to write overlap errors.
159 *
160 * Revision 3.81 2001/01/18 23:56:54 eokerson
161 * Fixed PSTN line test functions.
162 *
163 * Revision 3.80 2001/01/18 22:29:27 eokerson
164 * Updated AEC/AGC values for different cards.
165 *
166 * Revision 3.79 2001/01/17 02:58:54 eokerson
167 * Fixed AEC reset after Caller ID.
168 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
169 *
170 * Revision 3.78 2001/01/16 19:43:09 eokerson
171 * Added support for Linux 2.4.x kernels.
172 *
173 * Revision 3.77 2001/01/09 04:00:52 eokerson
174 * Linetest will now test the line, even if it has previously succeded.
175 *
176 * Revision 3.76 2001/01/08 19:27:00 eokerson
177 * Fixed problem with standard cable on Internet PhoneCARD.
178 *
179 * Revision 3.75 2000/12/22 16:52:14 eokerson
180 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
181 *
182 * Revision 3.74 2000/12/08 22:41:50 eokerson
183 * Added capability for G729B.
184 *
185 * Revision 3.73 2000/12/07 23:35:16 eokerson
186 * Added capability to have different ring pattern before CallerID data.
187 * Added hookstate checks in CallerID routines to stop FSK.
188 *
189 * Revision 3.72 2000/12/06 19:31:31 eokerson
190 * Modified signal behavior to only send one signal per event.
191 *
192 * Revision 3.71 2000/12/06 03:23:08 eokerson
193 * Fixed CallerID on Call Waiting.
194 *
195 * Revision 3.70 2000/12/04 21:29:37 eokerson
196 * Added checking to Smart Cable gain functions.
197 *
198 * Revision 3.69 2000/12/04 21:05:20 eokerson
199 * Changed ixjdebug levels.
200 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
201 *
202 * Revision 3.68 2000/12/04 00:17:21 craigs
203 * Changed mixer voice gain to +6dB rather than 0dB
204 *
205 * Revision 3.67 2000/11/30 21:25:51 eokerson
206 * Fixed write signal errors.
207 *
208 * Revision 3.66 2000/11/29 22:42:44 eokerson
209 * Fixed PSTN ring detect problems.
210 *
211 * Revision 3.65 2000/11/29 07:31:55 craigs
212 * Added new 425Hz filter co-efficients
213 * Added card-specific DTMF prescaler initialisation
214 *
215 * Revision 3.64 2000/11/28 14:03:32 craigs
216 * Changed certain mixer initialisations to be 0dB rather than 12dB
217 * Added additional information to /proc/ixj
218 *
219 * Revision 3.63 2000/11/28 11:38:41 craigs
220 * Added display of AEC modes in AUTO and AGC mode
221 *
222 * Revision 3.62 2000/11/28 04:05:44 eokerson
223 * Improved PSTN ring detection routine.
224 *
225 * Revision 3.61 2000/11/27 21:53:12 eokerson
226 * Fixed flash detection.
227 *
228 * Revision 3.60 2000/11/27 15:57:29 eokerson
229 * More work on G.729 load routines.
230 *
231 * Revision 3.59 2000/11/25 21:55:12 eokerson
232 * Fixed errors in G.729 load routine.
233 *
234 * Revision 3.58 2000/11/25 04:08:29 eokerson
235 * Added board locks around G.729 and TS85 load routines.
236 *
237 * Revision 3.57 2000/11/24 05:35:17 craigs
238 * Added ability to retrieve mixer values on LineJACK
239 * Added complete initialisation of all mixer values at startup
240 * Fixed spelling mistake
241 *
242 * Revision 3.56 2000/11/23 02:52:11 robertj
243 * Added cvs change log keyword.
244 * Fixed bug in capabilities list when using G.729 module.
245 *
246 */
247
248 #include "ixj-ver.h"
249
250 #define PERFMON_STATS
251 #define IXJDEBUG 0
252 #define MAXRINGS 5
253
254 #include <linux/module.h>
255
256 #include <linux/init.h>
257 #include <linux/sched.h>
258 #include <linux/kernel.h> /* printk() */
259 #include <linux/fs.h> /* everything... */
260 #include <linux/errno.h> /* error codes */
261 #include <linux/slab.h>
262 #include <linux/mm.h>
263 #include <linux/ioport.h>
264 #include <linux/interrupt.h>
265 #include <linux/proc_fs.h>
266 #include <linux/poll.h>
267 #include <linux/timer.h>
268 #include <linux/delay.h>
269 #include <linux/pci.h>
270
271 #include <asm/io.h>
272 #include <asm/uaccess.h>
273
274 #include <linux/isapnp.h>
275
276 #include "ixj.h"
277
278 #define TYPE(inode) (iminor(inode) >> 4)
279 #define NUM(inode) (iminor(inode) & 0xf)
280
281 static int ixjdebug;
282 static int hertz = HZ;
283 static int samplerate = 100;
284
285 module_param(ixjdebug, int, 0);
286
287 /************************************************************************
288 *
289 * ixjdebug meanings are now bit mapped instead of level based
290 * Values can be or'ed together to turn on multiple messages
291 *
292 * bit 0 (0x0001) = any failure
293 * bit 1 (0x0002) = general messages
294 * bit 2 (0x0004) = POTS ringing related
295 * bit 3 (0x0008) = PSTN events
296 * bit 4 (0x0010) = PSTN Cadence state details
297 * bit 5 (0x0020) = Tone detection triggers
298 * bit 6 (0x0040) = Tone detection cadence details
299 * bit 7 (0x0080) = ioctl tracking
300 * bit 8 (0x0100) = signal tracking
301 * bit 9 (0x0200) = CallerID generation details
302 *
303 ************************************************************************/
304
305 #ifdef IXJ_DYN_ALLOC
306
307 static IXJ *ixj[IXJMAX];
308 #define get_ixj(b) ixj[(b)]
309
310 /*
311 * Allocate a free IXJ device
312 */
313
314 static IXJ *ixj_alloc()
315 {
316 for(cnt=0; cnt<IXJMAX; cnt++)
317 {
318 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
319 {
320 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
321 if (j == NULL)
322 return NULL;
323 ixj[cnt] = j;
324 return j;
325 }
326 }
327 return NULL;
328 }
329
330 static void ixj_fsk_free(IXJ *j)
331 {
332 kfree(j->fskdata);
333 j->fskdata = NULL;
334 }
335
336 static void ixj_fsk_alloc(IXJ *j)
337 {
338 if(!j->fskdata) {
339 j->fskdata = kmalloc(8000, GFP_KERNEL);
340 if (!j->fskdata) {
341 if(ixjdebug & 0x0200) {
342 printk("IXJ phone%d - allocate failed\n", j->board);
343 }
344 return;
345 } else {
346 j->fsksize = 8000;
347 if(ixjdebug & 0x0200) {
348 printk("IXJ phone%d - allocate succeded\n", j->board);
349 }
350 }
351 }
352 }
353
354 #else
355
356 static IXJ ixj[IXJMAX];
357 #define get_ixj(b) (&ixj[(b)])
358
359 /*
360 * Allocate a free IXJ device
361 */
362
363 static IXJ *ixj_alloc(void)
364 {
365 int cnt;
366 for(cnt=0; cnt<IXJMAX; cnt++) {
367 if(!ixj[cnt].DSPbase)
368 return &ixj[cnt];
369 }
370 return NULL;
371 }
372
373 static inline void ixj_fsk_free(IXJ *j) {;}
374
375 static inline void ixj_fsk_alloc(IXJ *j)
376 {
377 j->fsksize = 8000;
378 }
379
380 #endif
381
382 #ifdef PERFMON_STATS
383 #define ixj_perfmon(x) ((x)++)
384 #else
385 #define ixj_perfmon(x) do { } while(0)
386 #endif
387
388 static int ixj_convert_loaded;
389
390 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
391
392 /************************************************************************
393 *
394 * These are function definitions to allow external modules to register
395 * enhanced functionality call backs.
396 *
397 ************************************************************************/
398
399 static int Stub(IXJ * J, unsigned long arg)
400 {
401 return 0;
402 }
403
404 static IXJ_REGFUNC ixj_PreRead = &Stub;
405 static IXJ_REGFUNC ixj_PostRead = &Stub;
406 static IXJ_REGFUNC ixj_PreWrite = &Stub;
407 static IXJ_REGFUNC ixj_PostWrite = &Stub;
408
409 static void ixj_read_frame(IXJ *j);
410 static void ixj_write_frame(IXJ *j);
411 static void ixj_init_timer(IXJ *j);
412 static void ixj_add_timer(IXJ * j);
413 static void ixj_timeout(unsigned long ptr);
414 static int read_filters(IXJ *j);
415 static int LineMonitor(IXJ *j);
416 static int ixj_fasync(int fd, struct file *, int mode);
417 static int ixj_set_port(IXJ *j, int arg);
418 static int ixj_set_pots(IXJ *j, int arg);
419 static int ixj_hookstate(IXJ *j);
420 static int ixj_record_start(IXJ *j);
421 static void ixj_record_stop(IXJ *j);
422 static void set_rec_volume(IXJ *j, int volume);
423 static int get_rec_volume(IXJ *j);
424 static int set_rec_codec(IXJ *j, int rate);
425 static void ixj_vad(IXJ *j, int arg);
426 static int ixj_play_start(IXJ *j);
427 static void ixj_play_stop(IXJ *j);
428 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
429 static int ixj_set_tone_off(unsigned short, IXJ *j);
430 static int ixj_play_tone(IXJ *j, char tone);
431 static void ixj_aec_start(IXJ *j, int level);
432 static int idle(IXJ *j);
433 static void ixj_ring_on(IXJ *j);
434 static void ixj_ring_off(IXJ *j);
435 static void aec_stop(IXJ *j);
436 static void ixj_ringback(IXJ *j);
437 static void ixj_busytone(IXJ *j);
438 static void ixj_dialtone(IXJ *j);
439 static void ixj_cpt_stop(IXJ *j);
440 static char daa_int_read(IXJ *j);
441 static char daa_CR_read(IXJ *j, int cr);
442 static int daa_set_mode(IXJ *j, int mode);
443 static int ixj_linetest(IXJ *j);
444 static int ixj_daa_write(IXJ *j);
445 static int ixj_daa_cid_read(IXJ *j);
446 static void DAA_Coeff_US(IXJ *j);
447 static void DAA_Coeff_UK(IXJ *j);
448 static void DAA_Coeff_France(IXJ *j);
449 static void DAA_Coeff_Germany(IXJ *j);
450 static void DAA_Coeff_Australia(IXJ *j);
451 static void DAA_Coeff_Japan(IXJ *j);
452 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
453 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
454 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
455 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
456 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
457 /* Serial Control Interface funtions */
458 static int SCI_Control(IXJ *j, int control);
459 static int SCI_Prepare(IXJ *j);
460 static int SCI_WaitHighSCI(IXJ *j);
461 static int SCI_WaitLowSCI(IXJ *j);
462 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
463 static int ixj_PCcontrol_wait(IXJ *j);
464 static void ixj_pre_cid(IXJ *j);
465 static void ixj_write_cid(IXJ *j);
466 static void ixj_write_cid_bit(IXJ *j, int bit);
467 static int set_base_frame(IXJ *j, int size);
468 static int set_play_codec(IXJ *j, int rate);
469 static void set_rec_depth(IXJ *j, int depth);
470 static int ixj_mixer(long val, IXJ *j);
471
472 /************************************************************************
473 CT8020/CT8021 Host Programmers Model
474 Host address Function Access
475 DSPbase +
476 0-1 Aux Software Status Register (reserved) Read Only
477 2-3 Software Status Register Read Only
478 4-5 Aux Software Control Register (reserved) Read Write
479 6-7 Software Control Register Read Write
480 8-9 Hardware Status Register Read Only
481 A-B Hardware Control Register Read Write
482 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
483 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
484 ************************************************************************/
485
486 static inline void ixj_read_HSR(IXJ *j)
487 {
488 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
489 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
490 }
491
492 static inline int IsControlReady(IXJ *j)
493 {
494 ixj_read_HSR(j);
495 return j->hsr.bits.controlrdy ? 1 : 0;
496 }
497
498 static inline int IsPCControlReady(IXJ *j)
499 {
500 j->pccr1.byte = inb_p(j->XILINXbase + 3);
501 return j->pccr1.bits.crr ? 1 : 0;
502 }
503
504 static inline int IsStatusReady(IXJ *j)
505 {
506 ixj_read_HSR(j);
507 return j->hsr.bits.statusrdy ? 1 : 0;
508 }
509
510 static inline int IsRxReady(IXJ *j)
511 {
512 ixj_read_HSR(j);
513 ixj_perfmon(j->rxreadycheck);
514 return j->hsr.bits.rxrdy ? 1 : 0;
515 }
516
517 static inline int IsTxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->txreadycheck);
521 return j->hsr.bits.txrdy ? 1 : 0;
522 }
523
524 static inline void set_play_volume(IXJ *j, int volume)
525 {
526 if (ixjdebug & 0x0002)
527 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
528 ixj_WriteDSPCommand(0xCF02, j);
529 ixj_WriteDSPCommand(volume, j);
530 }
531
532 static int set_play_volume_linear(IXJ *j, int volume)
533 {
534 int newvolume, dspplaymax;
535
536 if (ixjdebug & 0x0002)
537 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
538 if(volume > 100 || volume < 0) {
539 return -1;
540 }
541
542 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
543 switch (j->cardtype) {
544 case QTI_PHONEJACK:
545 dspplaymax = 0x380;
546 break;
547 case QTI_LINEJACK:
548 if(j->port == PORT_PSTN) {
549 dspplaymax = 0x48;
550 } else {
551 dspplaymax = 0x100;
552 }
553 break;
554 case QTI_PHONEJACK_LITE:
555 dspplaymax = 0x380;
556 break;
557 case QTI_PHONEJACK_PCI:
558 dspplaymax = 0x6C;
559 break;
560 case QTI_PHONECARD:
561 dspplaymax = 0x50;
562 break;
563 default:
564 return -1;
565 }
566 newvolume = (dspplaymax * volume) / 100;
567 set_play_volume(j, newvolume);
568 return 0;
569 }
570
571 static inline void set_play_depth(IXJ *j, int depth)
572 {
573 if (depth > 60)
574 depth = 60;
575 if (depth < 0)
576 depth = 0;
577 ixj_WriteDSPCommand(0x5280 + depth, j);
578 }
579
580 static inline int get_play_volume(IXJ *j)
581 {
582 ixj_WriteDSPCommand(0xCF00, j);
583 return j->ssr.high << 8 | j->ssr.low;
584 }
585
586 static int get_play_volume_linear(IXJ *j)
587 {
588 int volume, newvolume, dspplaymax;
589
590 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
591 switch (j->cardtype) {
592 case QTI_PHONEJACK:
593 dspplaymax = 0x380;
594 break;
595 case QTI_LINEJACK:
596 if(j->port == PORT_PSTN) {
597 dspplaymax = 0x48;
598 } else {
599 dspplaymax = 0x100;
600 }
601 break;
602 case QTI_PHONEJACK_LITE:
603 dspplaymax = 0x380;
604 break;
605 case QTI_PHONEJACK_PCI:
606 dspplaymax = 0x6C;
607 break;
608 case QTI_PHONECARD:
609 dspplaymax = 100;
610 break;
611 default:
612 return -1;
613 }
614 volume = get_play_volume(j);
615 newvolume = (volume * 100) / dspplaymax;
616 if(newvolume > 100)
617 newvolume = 100;
618 return newvolume;
619 }
620
621 static inline BYTE SLIC_GetState(IXJ *j)
622 {
623 if (j->cardtype == QTI_PHONECARD) {
624 j->pccr1.byte = 0;
625 j->psccr.bits.dev = 3;
626 j->psccr.bits.rw = 1;
627 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
628 ixj_PCcontrol_wait(j);
629 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
630 ixj_PCcontrol_wait(j);
631 if (j->pslic.bits.powerdown)
632 return PLD_SLIC_STATE_OC;
633 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
634 return PLD_SLIC_STATE_ACTIVE;
635 else
636 return PLD_SLIC_STATE_RINGING;
637 } else {
638 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
639 }
640 return j->pld_slicr.bits.state;
641 }
642
643 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
644 {
645 BOOL fRetVal = FALSE;
646
647 if (j->cardtype == QTI_PHONECARD) {
648 if (j->flags.pcmciasct) {
649 switch (byState) {
650 case PLD_SLIC_STATE_TIPOPEN:
651 case PLD_SLIC_STATE_OC:
652 j->pslic.bits.powerdown = 1;
653 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
654 fRetVal = TRUE;
655 break;
656 case PLD_SLIC_STATE_RINGING:
657 if (j->readers || j->writers) {
658 j->pslic.bits.powerdown = 0;
659 j->pslic.bits.ring0 = 1;
660 j->pslic.bits.ring1 = 0;
661 fRetVal = TRUE;
662 }
663 break;
664 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
665
666 case PLD_SLIC_STATE_STANDBY:
667 case PLD_SLIC_STATE_ACTIVE:
668 if (j->readers || j->writers) {
669 j->pslic.bits.powerdown = 0;
670 } else {
671 j->pslic.bits.powerdown = 1;
672 }
673 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
674 fRetVal = TRUE;
675 break;
676 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
677
678 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
679
680 default:
681 fRetVal = FALSE;
682 break;
683 }
684 j->psccr.bits.dev = 3;
685 j->psccr.bits.rw = 0;
686 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
687 ixj_PCcontrol_wait(j);
688 }
689 } else {
690 /* Set the C1, C2, C3 & B2EN signals. */
691 switch (byState) {
692 case PLD_SLIC_STATE_OC:
693 j->pld_slicw.bits.c1 = 0;
694 j->pld_slicw.bits.c2 = 0;
695 j->pld_slicw.bits.c3 = 0;
696 j->pld_slicw.bits.b2en = 0;
697 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
698 fRetVal = TRUE;
699 break;
700 case PLD_SLIC_STATE_RINGING:
701 j->pld_slicw.bits.c1 = 1;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 1;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
706 fRetVal = TRUE;
707 break;
708 case PLD_SLIC_STATE_ACTIVE:
709 j->pld_slicw.bits.c1 = 0;
710 j->pld_slicw.bits.c2 = 1;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 0;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
714 fRetVal = TRUE;
715 break;
716 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
717
718 j->pld_slicw.bits.c1 = 1;
719 j->pld_slicw.bits.c2 = 1;
720 j->pld_slicw.bits.c3 = 0;
721 j->pld_slicw.bits.b2en = 0;
722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
723 fRetVal = TRUE;
724 break;
725 case PLD_SLIC_STATE_TIPOPEN:
726 j->pld_slicw.bits.c1 = 0;
727 j->pld_slicw.bits.c2 = 0;
728 j->pld_slicw.bits.c3 = 1;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
731 fRetVal = TRUE;
732 break;
733 case PLD_SLIC_STATE_STANDBY:
734 j->pld_slicw.bits.c1 = 1;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 1;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
739 fRetVal = TRUE;
740 break;
741 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
742
743 j->pld_slicw.bits.c1 = 0;
744 j->pld_slicw.bits.c2 = 1;
745 j->pld_slicw.bits.c3 = 1;
746 j->pld_slicw.bits.b2en = 0;
747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
748 fRetVal = TRUE;
749 break;
750 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
751
752 j->pld_slicw.bits.c1 = 1;
753 j->pld_slicw.bits.c2 = 1;
754 j->pld_slicw.bits.c3 = 1;
755 j->pld_slicw.bits.b2en = 0;
756 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
757 fRetVal = TRUE;
758 break;
759 default:
760 fRetVal = FALSE;
761 break;
762 }
763 }
764
765 return fRetVal;
766 }
767
768 static int ixj_wink(IXJ *j)
769 {
770 BYTE slicnow;
771
772 slicnow = SLIC_GetState(j);
773
774 j->pots_winkstart = jiffies;
775 SLIC_SetState(PLD_SLIC_STATE_OC, j);
776
777 while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
778 set_current_state(TASK_INTERRUPTIBLE);
779 schedule_timeout(1);
780 }
781
782 SLIC_SetState(slicnow, j);
783 return 0;
784 }
785
786 static void ixj_init_timer(IXJ *j)
787 {
788 init_timer(&j->timer);
789 j->timer.function = ixj_timeout;
790 j->timer.data = (unsigned long)j;
791 }
792
793 static void ixj_add_timer(IXJ *j)
794 {
795 j->timer.expires = jiffies + (hertz / samplerate);
796 add_timer(&j->timer);
797 }
798
799 static void ixj_tone_timeout(IXJ *j)
800 {
801 IXJ_TONE ti;
802
803 j->tone_state++;
804 if (j->tone_state == 3) {
805 j->tone_state = 0;
806 if (j->cadence_t) {
807 j->tone_cadence_state++;
808 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
809 switch (j->cadence_t->termination) {
810 case PLAY_ONCE:
811 ixj_cpt_stop(j);
812 break;
813 case REPEAT_LAST_ELEMENT:
814 j->tone_cadence_state--;
815 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
816 break;
817 case REPEAT_ALL:
818 j->tone_cadence_state = 0;
819 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
820 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
821 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
822 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
823 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
824 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
825 ixj_init_tone(j, &ti);
826 }
827 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
828 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
829 ixj_play_tone(j, j->cadence_t->ce[0].index);
830 break;
831 }
832 } else {
833 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
834 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
835 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
836 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
837 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
838 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
839 ixj_init_tone(j, &ti);
840 }
841 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
842 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
843 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
844 }
845 }
846 }
847 }
848
849 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
850 {
851 if(j->ixj_signals[event]) {
852 if(ixjdebug & 0x0100)
853 printk("Sending signal for event %d\n", event);
854 /* Send apps notice of change */
855 /* see config.h for macro definition */
856 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
857 }
858 }
859
860 static void ixj_pstn_state(IXJ *j)
861 {
862 int var;
863 union XOPXR0 XR0, daaint;
864
865 var = 10;
866
867 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
868 daaint.reg = 0;
869 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
870
871 j->pld_scrr.byte = inb_p(j->XILINXbase);
872 if (j->pld_scrr.bits.daaflag) {
873 daa_int_read(j);
874 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
875 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
876 daaint.bitreg.RING = 1;
877 if(ixjdebug & 0x0008) {
878 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
879 }
880 } else {
881 daa_set_mode(j, SOP_PU_RESET);
882 }
883 }
884 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
885 daaint.bitreg.Caller_ID = 1;
886 j->pstn_cid_intr = 1;
887 j->pstn_cid_received = jiffies;
888 if(ixjdebug & 0x0008) {
889 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
890 }
891 }
892 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
893 daaint.bitreg.Cadence = 1;
894 if(ixjdebug & 0x0008) {
895 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
896 }
897 }
898 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
899 daaint.bitreg.VDD_OK = 1;
900 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
901 }
902 }
903 daa_CR_read(j, 1);
904 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)) {
905 daaint.bitreg.RMR = 1;
906 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
907 if(ixjdebug & 0x0008) {
908 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);
909 }
910 j->pstn_prev_rmr = j->pstn_last_rmr;
911 j->pstn_last_rmr = jiffies;
912 }
913 switch(j->daa_mode) {
914 case SOP_PU_SLEEP:
915 if (daaint.bitreg.RING) {
916 if (!j->flags.pstn_ringing) {
917 if (j->daa_mode != SOP_PU_RINGING) {
918 j->pstn_ring_int = jiffies;
919 daa_set_mode(j, SOP_PU_RINGING);
920 }
921 }
922 }
923 break;
924 case SOP_PU_RINGING:
925 if (daaint.bitreg.RMR) {
926 if (ixjdebug & 0x0008) {
927 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
928 }
929 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
930 j->flags.pstn_rmr = 1;
931 j->pstn_ring_start = jiffies;
932 j->pstn_ring_stop = 0;
933 j->ex.bits.pstn_ring = 0;
934 if (j->cadence_f[4].state == 0) {
935 j->cadence_f[4].state = 1;
936 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
937 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
938 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
939 } else if (j->cadence_f[4].state == 2) {
940 if((time_after(jiffies, j->cadence_f[4].off1min) &&
941 time_before(jiffies, j->cadence_f[4].off1max))) {
942 if (j->cadence_f[4].on2) {
943 j->cadence_f[4].state = 3;
944 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
945 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
946 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
947 } else {
948 j->cadence_f[4].state = 7;
949 }
950 } else {
951 if (ixjdebug & 0x0008) {
952 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
953 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
954 j->cadence_f[4].off1);
955 }
956 j->cadence_f[4].state = 0;
957 }
958 } else if (j->cadence_f[4].state == 4) {
959 if((time_after(jiffies, j->cadence_f[4].off2min) &&
960 time_before(jiffies, j->cadence_f[4].off2max))) {
961 if (j->cadence_f[4].on3) {
962 j->cadence_f[4].state = 5;
963 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
964 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
965 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
966 } else {
967 j->cadence_f[4].state = 7;
968 }
969 } else {
970 if (ixjdebug & 0x0008) {
971 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
972 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
973 j->cadence_f[4].off2);
974 }
975 j->cadence_f[4].state = 0;
976 }
977 } else if (j->cadence_f[4].state == 6) {
978 if((time_after(jiffies, j->cadence_f[4].off3min) &&
979 time_before(jiffies, j->cadence_f[4].off3max))) {
980 j->cadence_f[4].state = 7;
981 } else {
982 if (ixjdebug & 0x0008) {
983 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
984 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
985 j->cadence_f[4].off3);
986 }
987 j->cadence_f[4].state = 0;
988 }
989 } else {
990 j->cadence_f[4].state = 0;
991 }
992 } else { /* Falling edge of RMR */
993 j->pstn_ring_start = 0;
994 j->pstn_ring_stop = jiffies;
995 if (j->cadence_f[4].state == 1) {
996 if(!j->cadence_f[4].on1) {
997 j->cadence_f[4].state = 7;
998 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
999 time_before(jiffies, j->cadence_f[4].on1max))) {
1000 if (j->cadence_f[4].off1) {
1001 j->cadence_f[4].state = 2;
1002 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1003 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1004 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1005 } else {
1006 j->cadence_f[4].state = 7;
1007 }
1008 } else {
1009 if (ixjdebug & 0x0008) {
1010 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1011 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1012 j->cadence_f[4].on1);
1013 }
1014 j->cadence_f[4].state = 0;
1015 }
1016 } else if (j->cadence_f[4].state == 3) {
1017 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1018 time_before(jiffies, j->cadence_f[4].on2max))) {
1019 if (j->cadence_f[4].off2) {
1020 j->cadence_f[4].state = 4;
1021 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1022 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1023 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1024 } else {
1025 j->cadence_f[4].state = 7;
1026 }
1027 } else {
1028 if (ixjdebug & 0x0008) {
1029 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1030 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1031 j->cadence_f[4].on2);
1032 }
1033 j->cadence_f[4].state = 0;
1034 }
1035 } else if (j->cadence_f[4].state == 5) {
1036 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1037 time_before(jiffies, j->cadence_f[4].on3max))) {
1038 if (j->cadence_f[4].off3) {
1039 j->cadence_f[4].state = 6;
1040 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1041 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1042 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1043 } else {
1044 j->cadence_f[4].state = 7;
1045 }
1046 } else {
1047 j->cadence_f[4].state = 0;
1048 }
1049 } else {
1050 if (ixjdebug & 0x0008) {
1051 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1052 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1053 j->cadence_f[4].on3);
1054 }
1055 j->cadence_f[4].state = 0;
1056 }
1057 }
1058 if (ixjdebug & 0x0010) {
1059 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1060 }
1061 if (ixjdebug & 0x0010) {
1062 switch(j->cadence_f[4].state) {
1063 case 1:
1064 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1065 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1066 break;
1067 case 2:
1068 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1070 break;
1071 case 3:
1072 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1074 break;
1075 case 4:
1076 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1078 break;
1079 case 5:
1080 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1082 break;
1083 case 6:
1084 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1086 break;
1087 }
1088 }
1089 }
1090 if (j->cadence_f[4].state == 7) {
1091 j->cadence_f[4].state = 0;
1092 j->pstn_ring_stop = jiffies;
1093 j->ex.bits.pstn_ring = 1;
1094 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1095 if(ixjdebug & 0x0008) {
1096 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1097 }
1098 }
1099 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1100 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1101 if(ixjdebug & 0x0008) {
1102 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1103 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1104 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1105 }
1106 j->pstn_ring_stop = j->pstn_ring_int = 0;
1107 daa_set_mode(j, SOP_PU_SLEEP);
1108 }
1109 outb_p(j->pld_scrw.byte, j->XILINXbase);
1110 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1111 ixj_daa_cid_read(j);
1112 j->ex.bits.caller_id = 1;
1113 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1114 j->pstn_cid_intr = 0;
1115 }
1116 if (daaint.bitreg.Cadence) {
1117 if(ixjdebug & 0x0008) {
1118 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1119 }
1120 daa_set_mode(j, SOP_PU_SLEEP);
1121 j->ex.bits.pstn_ring = 0;
1122 }
1123 break;
1124 case SOP_PU_CONVERSATION:
1125 if (daaint.bitreg.VDD_OK) {
1126 if(!daaint.bitreg.SI_0) {
1127 if (!j->pstn_winkstart) {
1128 if(ixjdebug & 0x0008) {
1129 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1130 }
1131 j->pstn_winkstart = jiffies;
1132 }
1133 } else {
1134 if (j->pstn_winkstart) {
1135 if(ixjdebug & 0x0008) {
1136 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1137 }
1138 j->pstn_winkstart = 0;
1139 }
1140 }
1141 }
1142 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1143 if(ixjdebug & 0x0008) {
1144 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1145 }
1146 daa_set_mode(j, SOP_PU_SLEEP);
1147 j->pstn_winkstart = 0;
1148 j->ex.bits.pstn_wink = 1;
1149 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1150 }
1151 break;
1152 }
1153 }
1154
1155 static void ixj_timeout(unsigned long ptr)
1156 {
1157 int board;
1158 unsigned long jifon;
1159 IXJ *j = (IXJ *)ptr;
1160 board = j->board;
1161
1162 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1163 ixj_perfmon(j->timerchecks);
1164 j->hookstate = ixj_hookstate(j);
1165 if (j->tone_state) {
1166 if (!(j->hookstate)) {
1167 ixj_cpt_stop(j);
1168 if (j->m_hook) {
1169 j->m_hook = 0;
1170 j->ex.bits.hookstate = 1;
1171 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1172 }
1173 clear_bit(board, &j->busyflags);
1174 ixj_add_timer(j);
1175 return;
1176 }
1177 if (j->tone_state == 1)
1178 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1179 else
1180 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1181 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1182 if (j->tone_state == 1) {
1183 ixj_play_tone(j, j->tone_index);
1184 if (j->dsp.low == 0x20) {
1185 clear_bit(board, &j->busyflags);
1186 ixj_add_timer(j);
1187 return;
1188 }
1189 } else {
1190 ixj_play_tone(j, 0);
1191 if (j->dsp.low == 0x20) {
1192 clear_bit(board, &j->busyflags);
1193 ixj_add_timer(j);
1194 return;
1195 }
1196 }
1197 } else {
1198 ixj_tone_timeout(j);
1199 if (j->flags.dialtone) {
1200 ixj_dialtone(j);
1201 }
1202 if (j->flags.busytone) {
1203 ixj_busytone(j);
1204 if (j->dsp.low == 0x20) {
1205 clear_bit(board, &j->busyflags);
1206 ixj_add_timer(j);
1207 return;
1208 }
1209 }
1210 if (j->flags.ringback) {
1211 ixj_ringback(j);
1212 if (j->dsp.low == 0x20) {
1213 clear_bit(board, &j->busyflags);
1214 ixj_add_timer(j);
1215 return;
1216 }
1217 }
1218 if (!j->tone_state) {
1219 ixj_cpt_stop(j);
1220 }
1221 }
1222 }
1223 if (!(j->tone_state && j->dsp.low == 0x20)) {
1224 if (IsRxReady(j)) {
1225 ixj_read_frame(j);
1226 }
1227 if (IsTxReady(j)) {
1228 ixj_write_frame(j);
1229 }
1230 }
1231 if (j->flags.cringing) {
1232 if (j->hookstate & 1) {
1233 j->flags.cringing = 0;
1234 ixj_ring_off(j);
1235 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1236 switch(j->cadence_f[5].state) {
1237 case 0:
1238 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1239 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1240 if(ixjdebug & 0x0004) {
1241 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1242 }
1243 ixj_ring_on(j);
1244 }
1245 j->cadence_f[5].state = 1;
1246 break;
1247 case 1:
1248 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1249 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1250 if(ixjdebug & 0x0004) {
1251 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1252 }
1253 ixj_ring_off(j);
1254 j->cadence_f[5].state = 2;
1255 }
1256 break;
1257 case 2:
1258 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1259 if(ixjdebug & 0x0004) {
1260 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1261 }
1262 ixj_ring_on(j);
1263 if (j->cadence_f[5].on2) {
1264 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1265 j->cadence_f[5].state = 3;
1266 } else {
1267 j->cadence_f[5].state = 7;
1268 }
1269 }
1270 break;
1271 case 3:
1272 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1273 if(ixjdebug & 0x0004) {
1274 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1275 }
1276 ixj_ring_off(j);
1277 if (j->cadence_f[5].off2) {
1278 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1279 j->cadence_f[5].state = 4;
1280 } else {
1281 j->cadence_f[5].state = 7;
1282 }
1283 }
1284 break;
1285 case 4:
1286 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1287 if(ixjdebug & 0x0004) {
1288 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1289 }
1290 ixj_ring_on(j);
1291 if (j->cadence_f[5].on3) {
1292 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1293 j->cadence_f[5].state = 5;
1294 } else {
1295 j->cadence_f[5].state = 7;
1296 }
1297 }
1298 break;
1299 case 5:
1300 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1301 if(ixjdebug & 0x0004) {
1302 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1303 }
1304 ixj_ring_off(j);
1305 if (j->cadence_f[5].off3) {
1306 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1307 j->cadence_f[5].state = 6;
1308 } else {
1309 j->cadence_f[5].state = 7;
1310 }
1311 }
1312 break;
1313 case 6:
1314 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1315 if(ixjdebug & 0x0004) {
1316 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1317 }
1318 j->cadence_f[5].state = 7;
1319 }
1320 break;
1321 case 7:
1322 if(ixjdebug & 0x0004) {
1323 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1324 }
1325 j->flags.cidring = 1;
1326 j->cadence_f[5].state = 0;
1327 break;
1328 }
1329 if (j->flags.cidring && !j->flags.cidsent) {
1330 j->flags.cidsent = 1;
1331 if(j->fskdcnt) {
1332 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1333 ixj_pre_cid(j);
1334 }
1335 j->flags.cidring = 0;
1336 }
1337 clear_bit(board, &j->busyflags);
1338 ixj_add_timer(j);
1339 return;
1340 } else {
1341 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1342 if (j->flags.cidring && !j->flags.cidsent) {
1343 j->flags.cidsent = 1;
1344 if(j->fskdcnt) {
1345 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1346 ixj_pre_cid(j);
1347 }
1348 j->flags.cidring = 0;
1349 }
1350 j->ring_cadence_t--;
1351 if (j->ring_cadence_t == -1)
1352 j->ring_cadence_t = 15;
1353 j->ring_cadence_jif = jiffies;
1354
1355 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1356 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1357 j->flags.firstring = 1;
1358 else
1359 ixj_ring_on(j);
1360 } else {
1361 ixj_ring_off(j);
1362 if(!j->flags.cidsent)
1363 j->flags.cidring = 1;
1364 }
1365 }
1366 clear_bit(board, &j->busyflags);
1367 ixj_add_timer(j);
1368 return;
1369 }
1370 }
1371 if (!j->flags.ringing) {
1372 if (j->hookstate) { /* & 1) { */
1373 if (j->dsp.low != 0x20 &&
1374 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1375 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1376 }
1377 LineMonitor(j);
1378 read_filters(j);
1379 ixj_WriteDSPCommand(0x511B, j);
1380 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1381 if (!j->m_hook && (j->hookstate & 1)) {
1382 j->m_hook = j->ex.bits.hookstate = 1;
1383 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1384 }
1385 } else {
1386 if (j->ex.bits.dtmf_ready) {
1387 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1388 }
1389 if (j->m_hook) {
1390 j->m_hook = 0;
1391 j->ex.bits.hookstate = 1;
1392 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1393 }
1394 }
1395 }
1396 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1397 ixj_pstn_state(j);
1398 }
1399 if (j->ex.bytes) {
1400 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1401 }
1402 clear_bit(board, &j->busyflags);
1403 }
1404 ixj_add_timer(j);
1405 }
1406
1407 static int ixj_status_wait(IXJ *j)
1408 {
1409 unsigned long jif;
1410
1411 jif = jiffies + ((60 * hertz) / 100);
1412 while (!IsStatusReady(j)) {
1413 ixj_perfmon(j->statuswait);
1414 if (time_after(jiffies, jif)) {
1415 ixj_perfmon(j->statuswaitfail);
1416 return -1;
1417 }
1418 }
1419 return 0;
1420 }
1421
1422 static int ixj_PCcontrol_wait(IXJ *j)
1423 {
1424 unsigned long jif;
1425
1426 jif = jiffies + ((60 * hertz) / 100);
1427 while (!IsPCControlReady(j)) {
1428 ixj_perfmon(j->pcontrolwait);
1429 if (time_after(jiffies, jif)) {
1430 ixj_perfmon(j->pcontrolwaitfail);
1431 return -1;
1432 }
1433 }
1434 return 0;
1435 }
1436
1437 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1438 {
1439 BYTES bytes;
1440 unsigned long jif;
1441
1442 atomic_inc(&j->DSPWrite);
1443 if(atomic_read(&j->DSPWrite) > 1) {
1444 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1445 return -1;
1446 }
1447 bytes.high = (cmd & 0xFF00) >> 8;
1448 bytes.low = cmd & 0x00FF;
1449 jif = jiffies + ((60 * hertz) / 100);
1450 while (!IsControlReady(j)) {
1451 ixj_perfmon(j->iscontrolready);
1452 if (time_after(jiffies, jif)) {
1453 ixj_perfmon(j->iscontrolreadyfail);
1454 atomic_dec(&j->DSPWrite);
1455 if(atomic_read(&j->DSPWrite) > 0) {
1456 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1457 while(atomic_read(&j->DSPWrite) > 0) {
1458 atomic_dec(&j->DSPWrite);
1459 }
1460 }
1461 return -1;
1462 }
1463 }
1464 outb(bytes.low, j->DSPbase + 6);
1465 outb(bytes.high, j->DSPbase + 7);
1466
1467 if (ixj_status_wait(j)) {
1468 j->ssr.low = 0xFF;
1469 j->ssr.high = 0xFF;
1470 atomic_dec(&j->DSPWrite);
1471 if(atomic_read(&j->DSPWrite) > 0) {
1472 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1473 while(atomic_read(&j->DSPWrite) > 0) {
1474 atomic_dec(&j->DSPWrite);
1475 }
1476 }
1477 return -1;
1478 }
1479 /* Read Software Status Register */
1480 j->ssr.low = inb_p(j->DSPbase + 2);
1481 j->ssr.high = inb_p(j->DSPbase + 3);
1482 atomic_dec(&j->DSPWrite);
1483 if(atomic_read(&j->DSPWrite) > 0) {
1484 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1485 while(atomic_read(&j->DSPWrite) > 0) {
1486 atomic_dec(&j->DSPWrite);
1487 }
1488 }
1489 return 0;
1490 }
1491
1492 /***************************************************************************
1493 *
1494 * General Purpose IO Register read routine
1495 *
1496 ***************************************************************************/
1497 static inline int ixj_gpio_read(IXJ *j)
1498 {
1499 if (ixj_WriteDSPCommand(0x5143, j))
1500 return -1;
1501
1502 j->gpio.bytes.low = j->ssr.low;
1503 j->gpio.bytes.high = j->ssr.high;
1504
1505 return 0;
1506 }
1507
1508 static inline void LED_SetState(int state, IXJ *j)
1509 {
1510 if (j->cardtype == QTI_LINEJACK) {
1511 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1512 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1513 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1514 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1515
1516 outb(j->pld_scrw.byte, j->XILINXbase);
1517 }
1518 }
1519
1520 /*********************************************************************
1521 * GPIO Pins are configured as follows on the Quicknet Internet
1522 * PhoneJACK Telephony Cards
1523 *
1524 * POTS Select GPIO_6=0 GPIO_7=0
1525 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1526 * Handset Select GPIO_6=1 GPIO_7=0
1527 *
1528 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1529 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1530 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1531 *
1532 * Hook Switch changes reported on GPIO_3
1533 *********************************************************************/
1534 static int ixj_set_port(IXJ *j, int arg)
1535 {
1536 if (j->cardtype == QTI_PHONEJACK_LITE) {
1537 if (arg != PORT_POTS)
1538 return 10;
1539 else
1540 return 0;
1541 }
1542 switch (arg) {
1543 case PORT_POTS:
1544 j->port = PORT_POTS;
1545 switch (j->cardtype) {
1546 case QTI_PHONECARD:
1547 if (j->flags.pcmciasct == 1)
1548 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1549 else
1550 return 11;
1551 break;
1552 case QTI_PHONEJACK_PCI:
1553 j->pld_slicw.pcib.mic = 0;
1554 j->pld_slicw.pcib.spk = 0;
1555 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1556 break;
1557 case QTI_LINEJACK:
1558 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1559 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1560 Software Control Register */
1561 return 2;
1562 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1563
1564 outb(j->pld_scrw.byte, j->XILINXbase);
1565 j->pld_clock.byte = 0;
1566 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1567 j->pld_slicw.bits.rly1 = 1;
1568 j->pld_slicw.bits.spken = 0;
1569 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1570 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1571 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1572 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1573 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1574 ixj_mixer(0x0E80, j); /*Mic mute */
1575 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1576 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1577 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1578 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1579 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1580 break;
1581 case QTI_PHONEJACK:
1582 j->gpio.bytes.high = 0x0B;
1583 j->gpio.bits.gpio6 = 0;
1584 j->gpio.bits.gpio7 = 0;
1585 ixj_WriteDSPCommand(j->gpio.word, j);
1586 break;
1587 }
1588 break;
1589 case PORT_PSTN:
1590 if (j->cardtype == QTI_LINEJACK) {
1591 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1592
1593 j->pld_slicw.bits.rly3 = 0;
1594 j->pld_slicw.bits.rly1 = 1;
1595 j->pld_slicw.bits.spken = 0;
1596 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1597 j->port = PORT_PSTN;
1598 } else {
1599 return 4;
1600 }
1601 break;
1602 case PORT_SPEAKER:
1603 j->port = PORT_SPEAKER;
1604 switch (j->cardtype) {
1605 case QTI_PHONECARD:
1606 if (j->flags.pcmciasct) {
1607 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1608 }
1609 break;
1610 case QTI_PHONEJACK_PCI:
1611 j->pld_slicw.pcib.mic = 1;
1612 j->pld_slicw.pcib.spk = 1;
1613 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1614 break;
1615 case QTI_LINEJACK:
1616 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1617 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1618 Software Control Register */
1619 return 2;
1620 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1621
1622 outb(j->pld_scrw.byte, j->XILINXbase);
1623 j->pld_clock.byte = 0;
1624 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1625 j->pld_slicw.bits.rly1 = 1;
1626 j->pld_slicw.bits.spken = 1;
1627 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1628 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1629 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1630 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1631 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1632 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1633 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1634 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1635 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1636 break;
1637 case QTI_PHONEJACK:
1638 j->gpio.bytes.high = 0x0B;
1639 j->gpio.bits.gpio6 = 0;
1640 j->gpio.bits.gpio7 = 1;
1641 ixj_WriteDSPCommand(j->gpio.word, j);
1642 break;
1643 }
1644 break;
1645 case PORT_HANDSET:
1646 if (j->cardtype != QTI_PHONEJACK) {
1647 return 5;
1648 } else {
1649 j->gpio.bytes.high = 0x0B;
1650 j->gpio.bits.gpio6 = 1;
1651 j->gpio.bits.gpio7 = 0;
1652 ixj_WriteDSPCommand(j->gpio.word, j);
1653 j->port = PORT_HANDSET;
1654 }
1655 break;
1656 default:
1657 return 6;
1658 break;
1659 }
1660 return 0;
1661 }
1662
1663 static int ixj_set_pots(IXJ *j, int arg)
1664 {
1665 if (j->cardtype == QTI_LINEJACK) {
1666 if (arg) {
1667 if (j->port == PORT_PSTN) {
1668 j->pld_slicw.bits.rly1 = 0;
1669 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1670 j->flags.pots_pstn = 1;
1671 return 1;
1672 } else {
1673 j->flags.pots_pstn = 0;
1674 return 0;
1675 }
1676 } else {
1677 j->pld_slicw.bits.rly1 = 1;
1678 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1679 j->flags.pots_pstn = 0;
1680 return 1;
1681 }
1682 } else {
1683 return 0;
1684 }
1685 }
1686
1687 static void ixj_ring_on(IXJ *j)
1688 {
1689 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1690 {
1691 if (ixjdebug & 0x0004)
1692 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1693
1694 j->gpio.bytes.high = 0x0B;
1695 j->gpio.bytes.low = 0x00;
1696 j->gpio.bits.gpio1 = 1;
1697 j->gpio.bits.gpio2 = 1;
1698 j->gpio.bits.gpio5 = 0;
1699 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1700 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1701 {
1702 if (ixjdebug & 0x0004)
1703 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1704
1705 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1706 }
1707 }
1708
1709 static int ixj_siadc(IXJ *j, int val)
1710 {
1711 if(j->cardtype == QTI_PHONECARD){
1712 if(j->flags.pcmciascp){
1713 if(val == -1)
1714 return j->siadc.bits.rxg;
1715
1716 if(val < 0 || val > 0x1F)
1717 return -1;
1718
1719 j->siadc.bits.hom = 0; /* Handset Out Mute */
1720 j->siadc.bits.lom = 0; /* Line Out Mute */
1721 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1722 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1723 j->psccr.bits.rw = 0; /* Read / Write flag */
1724 j->psccr.bits.dev = 0;
1725 outb(j->siadc.byte, j->XILINXbase + 0x00);
1726 outb(j->psccr.byte, j->XILINXbase + 0x01);
1727 ixj_PCcontrol_wait(j);
1728 return j->siadc.bits.rxg;
1729 }
1730 }
1731 return -1;
1732 }
1733
1734 static int ixj_sidac(IXJ *j, int val)
1735 {
1736 if(j->cardtype == QTI_PHONECARD){
1737 if(j->flags.pcmciascp){
1738 if(val == -1)
1739 return j->sidac.bits.txg;
1740
1741 if(val < 0 || val > 0x1F)
1742 return -1;
1743
1744 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1745 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1746 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1747 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1748 j->psccr.bits.rw = 0; /* Read / Write flag */
1749 j->psccr.bits.dev = 0;
1750 outb(j->sidac.byte, j->XILINXbase + 0x00);
1751 outb(j->psccr.byte, j->XILINXbase + 0x01);
1752 ixj_PCcontrol_wait(j);
1753 return j->sidac.bits.txg;
1754 }
1755 }
1756 return -1;
1757 }
1758
1759 static int ixj_pcmcia_cable_check(IXJ *j)
1760 {
1761 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1762 if (!j->flags.pcmciastate) {
1763 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1764 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1765 j->flags.pcmciastate = 4;
1766 return 0;
1767 }
1768 if (j->pccr1.bits.ed) {
1769 j->pccr1.bits.ed = 0;
1770 j->psccr.bits.dev = 3;
1771 j->psccr.bits.rw = 1;
1772 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1773 ixj_PCcontrol_wait(j);
1774 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1775 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1776 j->psccr.bits.dev = 3;
1777 j->psccr.bits.rw = 0;
1778 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1779 ixj_PCcontrol_wait(j);
1780 return j->pslic.bits.led2 ? 1 : 0;
1781 } else if (j->flags.pcmciasct) {
1782 return j->r_hook;
1783 } else {
1784 return 1;
1785 }
1786 } else if (j->flags.pcmciastate == 4) {
1787 if (!j->pccr1.bits.drf) {
1788 j->flags.pcmciastate = 3;
1789 }
1790 return 0;
1791 } else if (j->flags.pcmciastate == 3) {
1792 j->pccr2.bits.pwr = 0;
1793 j->pccr2.bits.rstc = 1;
1794 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1795 j->checkwait = jiffies + (hertz * 2);
1796 j->flags.incheck = 1;
1797 j->flags.pcmciastate = 2;
1798 return 0;
1799 } else if (j->flags.pcmciastate == 2) {
1800 if (j->flags.incheck) {
1801 if (time_before(jiffies, j->checkwait)) {
1802 return 0;
1803 } else {
1804 j->flags.incheck = 0;
1805 }
1806 }
1807 j->pccr2.bits.pwr = 0;
1808 j->pccr2.bits.rstc = 0;
1809 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1810 j->flags.pcmciastate = 1;
1811 return 0;
1812 } else if (j->flags.pcmciastate == 1) {
1813 j->flags.pcmciastate = 0;
1814 if (!j->pccr1.bits.drf) {
1815 j->psccr.bits.dev = 3;
1816 j->psccr.bits.rw = 1;
1817 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1818 ixj_PCcontrol_wait(j);
1819 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1820
1821 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1822
1823 if (j->flags.pcmciasct == 3) {
1824 j->flags.pcmciastate = 4;
1825 return 0;
1826 } else if (j->flags.pcmciasct == 0) {
1827 j->pccr2.bits.pwr = 1;
1828 j->pccr2.bits.rstc = 0;
1829 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1830 j->port = PORT_SPEAKER;
1831 } else {
1832 j->port = PORT_POTS;
1833 }
1834 j->sic1.bits.cpd = 0; /* Chip Power Down */
1835 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1836 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1837 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1838 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1839 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1840 j->psccr.bits.rw = 0; /* Read / Write flag */
1841 j->psccr.bits.dev = 0;
1842 outb(j->sic1.byte, j->XILINXbase + 0x00);
1843 outb(j->psccr.byte, j->XILINXbase + 0x01);
1844 ixj_PCcontrol_wait(j);
1845
1846 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1847 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1848 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1849 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1850 j->sic2.bits.hpd = 0; /* HPF disable */
1851 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1852 j->psccr.bits.rw = 0; /* Read / Write flag */
1853 j->psccr.bits.dev = 0;
1854 outb(j->sic2.byte, j->XILINXbase + 0x00);
1855 outb(j->psccr.byte, j->XILINXbase + 0x01);
1856 ixj_PCcontrol_wait(j);
1857
1858 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1859 j->psccr.bits.rw = 0; /* Read / Write flag */
1860 j->psccr.bits.dev = 0;
1861 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1862 outb(j->psccr.byte, j->XILINXbase + 0x01);
1863 ixj_PCcontrol_wait(j);
1864
1865 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1866 j->psccr.bits.rw = 0; /* Read / Write flag */
1867 j->psccr.bits.dev = 0;
1868 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1869 outb(j->psccr.byte, j->XILINXbase + 0x01);
1870 ixj_PCcontrol_wait(j);
1871
1872 j->sirxg.bits.lig = 1; /* Line In Gain */
1873 j->sirxg.bits.lim = 1; /* Line In Mute */
1874 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1875 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1876 j->sirxg.bits.him = 0; /* Handset In Mute */
1877 j->sirxg.bits.iir = 1; /* IIR */
1878 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1879 j->psccr.bits.rw = 0; /* Read / Write flag */
1880 j->psccr.bits.dev = 0;
1881 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1882 outb(j->psccr.byte, j->XILINXbase + 0x01);
1883 ixj_PCcontrol_wait(j);
1884
1885 ixj_siadc(j, 0x17);
1886 ixj_sidac(j, 0x1D);
1887
1888 j->siaatt.bits.sot = 0;
1889 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1890 j->psccr.bits.rw = 0; /* Read / Write flag */
1891 j->psccr.bits.dev = 0;
1892 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1893 outb(j->psccr.byte, j->XILINXbase + 0x01);
1894 ixj_PCcontrol_wait(j);
1895
1896 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1897 j->psccr.byte = j->pslic.byte = 0;
1898 j->pslic.bits.powerdown = 1;
1899 j->psccr.bits.dev = 3;
1900 j->psccr.bits.rw = 0;
1901 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1902 ixj_PCcontrol_wait(j);
1903 }
1904 }
1905 return 0;
1906 } else {
1907 j->flags.pcmciascp = 0;
1908 return 0;
1909 }
1910 return 0;
1911 }
1912
1913 static int ixj_hookstate(IXJ *j)
1914 {
1915 unsigned long det;
1916 int fOffHook = 0;
1917
1918 switch (j->cardtype) {
1919 case QTI_PHONEJACK:
1920 ixj_gpio_read(j);
1921 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1922 break;
1923 case QTI_LINEJACK:
1924 case QTI_PHONEJACK_LITE:
1925 case QTI_PHONEJACK_PCI:
1926 SLIC_GetState(j);
1927 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1928 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1929 if(fOffHook != j->p_hook) {
1930 if(!j->checkwait) {
1931 j->checkwait = jiffies;
1932 }
1933 if(time_before(jiffies, j->checkwait + 2)) {
1934 fOffHook ^= 1;
1935 } else {
1936 j->checkwait = 0;
1937 }
1938 j->p_hook = fOffHook;
1939 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1940 }
1941 } else {
1942 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1943 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1944 if (j->flags.ringing || j->flags.cringing) {
1945 if (!in_interrupt()) {
1946 det = jiffies + (hertz / 50);
1947 while (time_before(jiffies, det)) {
1948 set_current_state(TASK_INTERRUPTIBLE);
1949 schedule_timeout(1);
1950 }
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, det;
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 det = 0;
2074 for (cntr = 0; cntr < j->maxrings; cntr++) {
2075 jif = jiffies + (1 * hertz);
2076 ixj_ring_on(j);
2077 while (time_before(jiffies, jif)) {
2078 if (ixj_hookstate(j) & 1) {
2079 ixj_ring_off(j);
2080 j->flags.ringing = 0;
2081 return 1;
2082 }
2083 set_current_state(TASK_INTERRUPTIBLE);
2084 schedule_timeout(1);
2085 if (signal_pending(current))
2086 break;
2087 }
2088 jif = jiffies + (3 * hertz);
2089 ixj_ring_off(j);
2090 while (time_before(jiffies, jif)) {
2091 if (ixj_hookstate(j) & 1) {
2092 det = jiffies + (hertz / 100);
2093 while (time_before(jiffies, det)) {
2094 set_current_state(TASK_INTERRUPTIBLE);
2095 schedule_timeout(1);
2096 if (signal_pending(current))
2097 break;
2098 }
2099 if (ixj_hookstate(j) & 1) {
2100 j->flags.ringing = 0;
2101 return 1;
2102 }
2103 }
2104 set_current_state(TASK_INTERRUPTIBLE);
2105 schedule_timeout(1);
2106 if (signal_pending(current))
2107 break;
2108 }
2109 }
2110 ixj_ring_off(j);
2111 j->flags.ringing = 0;
2112 return 0;
2113 }
2114
2115 static int ixj_open(struct phone_device *p, struct file *file_p)
2116 {
2117 IXJ *j = get_ixj(p->board);
2118 file_p->private_data = j;
2119
2120 if (!j->DSPbase)
2121 return -ENODEV;
2122
2123 if (file_p->f_mode & FMODE_READ) {
2124 if(!j->readers) {
2125 j->readers++;
2126 } else {
2127 return -EBUSY;
2128 }
2129 }
2130
2131 if (file_p->f_mode & FMODE_WRITE) {
2132 if(!j->writers) {
2133 j->writers++;
2134 } else {
2135 if (file_p->f_mode & FMODE_READ){
2136 j->readers--;
2137 }
2138 return -EBUSY;
2139 }
2140 }
2141
2142 if (j->cardtype == QTI_PHONECARD) {
2143 j->pslic.bits.powerdown = 0;
2144 j->psccr.bits.dev = 3;
2145 j->psccr.bits.rw = 0;
2146 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2147 ixj_PCcontrol_wait(j);
2148 }
2149
2150 j->flags.cidplay = 0;
2151 j->flags.cidcw_ack = 0;
2152
2153 if (ixjdebug & 0x0002)
2154 printk(KERN_INFO "Opening board %d\n", p->board);
2155
2156 j->framesread = j->frameswritten = 0;
2157 return 0;
2158 }
2159
2160 static int ixj_release(struct inode *inode, struct file *file_p)
2161 {
2162 IXJ_TONE ti;
2163 int cnt;
2164 IXJ *j = file_p->private_data;
2165 int board = j->p.board;
2166
2167 /*
2168 * Set up locks to ensure that only one process is talking to the DSP at a time.
2169 * This is necessary to keep the DSP from locking up.
2170 */
2171 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2172 set_current_state(TASK_INTERRUPTIBLE);
2173 schedule_timeout(1);
2174 }
2175 if (ixjdebug & 0x0002)
2176 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2177
2178 if (j->cardtype == QTI_PHONECARD)
2179 ixj_set_port(j, PORT_SPEAKER);
2180 else
2181 ixj_set_port(j, PORT_POTS);
2182
2183 aec_stop(j);
2184 ixj_play_stop(j);
2185 ixj_record_stop(j);
2186 set_play_volume(j, 0x100);
2187 set_rec_volume(j, 0x100);
2188 ixj_ring_off(j);
2189
2190 /* Restore the tone table to default settings. */
2191 ti.tone_index = 10;
2192 ti.gain0 = 1;
2193 ti.freq0 = hz941;
2194 ti.gain1 = 0;
2195 ti.freq1 = hz1209;
2196 ixj_init_tone(j, &ti);
2197 ti.tone_index = 11;
2198 ti.gain0 = 1;
2199 ti.freq0 = hz941;
2200 ti.gain1 = 0;
2201 ti.freq1 = hz1336;
2202 ixj_init_tone(j, &ti);
2203 ti.tone_index = 12;
2204 ti.gain0 = 1;
2205 ti.freq0 = hz941;
2206 ti.gain1 = 0;
2207 ti.freq1 = hz1477;
2208 ixj_init_tone(j, &ti);
2209 ti.tone_index = 13;
2210 ti.gain0 = 1;
2211 ti.freq0 = hz800;
2212 ti.gain1 = 0;
2213 ti.freq1 = 0;
2214 ixj_init_tone(j, &ti);
2215 ti.tone_index = 14;
2216 ti.gain0 = 1;
2217 ti.freq0 = hz1000;
2218 ti.gain1 = 0;
2219 ti.freq1 = 0;
2220 ixj_init_tone(j, &ti);
2221 ti.tone_index = 15;
2222 ti.gain0 = 1;
2223 ti.freq0 = hz1250;
2224 ti.gain1 = 0;
2225 ti.freq1 = 0;
2226 ixj_init_tone(j, &ti);
2227 ti.tone_index = 16;
2228 ti.gain0 = 1;
2229 ti.freq0 = hz950;
2230 ti.gain1 = 0;
2231 ti.freq1 = 0;
2232 ixj_init_tone(j, &ti);
2233 ti.tone_index = 17;
2234 ti.gain0 = 1;
2235 ti.freq0 = hz1100;
2236 ti.gain1 = 0;
2237 ti.freq1 = 0;
2238 ixj_init_tone(j, &ti);
2239 ti.tone_index = 18;
2240 ti.gain0 = 1;
2241 ti.freq0 = hz1400;
2242 ti.gain1 = 0;
2243 ti.freq1 = 0;
2244 ixj_init_tone(j, &ti);
2245 ti.tone_index = 19;
2246 ti.gain0 = 1;
2247 ti.freq0 = hz1500;
2248 ti.gain1 = 0;
2249 ti.freq1 = 0;
2250 ixj_init_tone(j, &ti);
2251 ti.tone_index = 20;
2252 ti.gain0 = 1;
2253 ti.freq0 = hz1600;
2254 ti.gain1 = 0;
2255 ti.freq1 = 0;
2256 ixj_init_tone(j, &ti);
2257 ti.tone_index = 21;
2258 ti.gain0 = 1;
2259 ti.freq0 = hz1800;
2260 ti.gain1 = 0;
2261 ti.freq1 = 0;
2262 ixj_init_tone(j, &ti);
2263 ti.tone_index = 22;
2264 ti.gain0 = 1;
2265 ti.freq0 = hz2100;
2266 ti.gain1 = 0;
2267 ti.freq1 = 0;
2268 ixj_init_tone(j, &ti);
2269 ti.tone_index = 23;
2270 ti.gain0 = 1;
2271 ti.freq0 = hz1300;
2272 ti.gain1 = 0;
2273 ti.freq1 = 0;
2274 ixj_init_tone(j, &ti);
2275 ti.tone_index = 24;
2276 ti.gain0 = 1;
2277 ti.freq0 = hz2450;
2278 ti.gain1 = 0;
2279 ti.freq1 = 0;
2280 ixj_init_tone(j, &ti);
2281 ti.tone_index = 25;
2282 ti.gain0 = 1;
2283 ti.freq0 = hz350;
2284 ti.gain1 = 0;
2285 ti.freq1 = hz440;
2286 ixj_init_tone(j, &ti);
2287 ti.tone_index = 26;
2288 ti.gain0 = 1;
2289 ti.freq0 = hz440;
2290 ti.gain1 = 0;
2291 ti.freq1 = hz480;
2292 ixj_init_tone(j, &ti);
2293 ti.tone_index = 27;
2294 ti.gain0 = 1;
2295 ti.freq0 = hz480;
2296 ti.gain1 = 0;
2297 ti.freq1 = hz620;
2298 ixj_init_tone(j, &ti);
2299
2300 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2301
2302 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2303
2304 j->ex.bits.dtmf_ready = 0;
2305 j->dtmf_state = 0;
2306 j->dtmf_wp = j->dtmf_rp = 0;
2307 j->rec_mode = j->play_mode = -1;
2308 j->flags.ringing = 0;
2309 j->maxrings = MAXRINGS;
2310 j->ring_cadence = USA_RING_CADENCE;
2311 if(j->cadence_f[5].enable) {
2312 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2313 }
2314 j->drybuffer = 0;
2315 j->winktime = 320;
2316 j->flags.dtmf_oob = 0;
2317 for (cnt = 0; cnt < 4; cnt++)
2318 j->cadence_f[cnt].enable = 0;
2319
2320 idle(j);
2321
2322 if(j->cardtype == QTI_PHONECARD) {
2323 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2324 }
2325
2326 if (file_p->f_mode & FMODE_READ)
2327 j->readers--;
2328 if (file_p->f_mode & FMODE_WRITE)
2329 j->writers--;
2330
2331 if (j->read_buffer && !j->readers) {
2332 kfree(j->read_buffer);
2333 j->read_buffer = NULL;
2334 j->read_buffer_size = 0;
2335 }
2336 if (j->write_buffer && !j->writers) {
2337 kfree(j->write_buffer);
2338 j->write_buffer = NULL;
2339 j->write_buffer_size = 0;
2340 }
2341 j->rec_codec = j->play_codec = 0;
2342 j->rec_frame_size = j->play_frame_size = 0;
2343 j->flags.cidsent = j->flags.cidring = 0;
2344 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2345
2346 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2347 ixj_set_port(j, PORT_PSTN);
2348 daa_set_mode(j, SOP_PU_SLEEP);
2349 ixj_set_pots(j, 1);
2350 }
2351 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2352
2353 /* Set up the default signals for events */
2354 for (cnt = 0; cnt < 35; cnt++)
2355 j->ixj_signals[cnt] = SIGIO;
2356
2357 /* Set the excetion signal enable flags */
2358 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2359 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 =
2360 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;
2361
2362 file_p->private_data = NULL;
2363 clear_bit(board, &j->busyflags);
2364 return 0;
2365 }
2366
2367 static int read_filters(IXJ *j)
2368 {
2369 unsigned short fc, cnt, trg;
2370 int var;
2371
2372 trg = 0;
2373 if (ixj_WriteDSPCommand(0x5144, j)) {
2374 if(ixjdebug & 0x0001) {
2375 printk(KERN_INFO "Read Frame Counter failed!\n");
2376 }
2377 return -1;
2378 }
2379 fc = j->ssr.high << 8 | j->ssr.low;
2380 if (fc == j->frame_count)
2381 return 1;
2382
2383 j->frame_count = fc;
2384
2385 if (j->dtmf_proc)
2386 return 1;
2387
2388 var = 10;
2389
2390 for (cnt = 0; cnt < 4; cnt++) {
2391 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2392 if(ixjdebug & 0x0001) {
2393 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2394 }
2395 return -1;
2396 }
2397 if (ixj_WriteDSPCommand(0x515C, j)) {
2398 if(ixjdebug & 0x0001) {
2399 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2400 }
2401 return -1;
2402 }
2403 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2404
2405 if (j->cadence_f[cnt].enable) {
2406 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2407 if (j->cadence_f[cnt].state == 0) {
2408 j->cadence_f[cnt].state = 1;
2409 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2410 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2411 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2412 } else if (j->cadence_f[cnt].state == 2 &&
2413 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2414 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2415 if (j->cadence_f[cnt].on2) {
2416 j->cadence_f[cnt].state = 3;
2417 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2418 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2419 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2420 } else {
2421 j->cadence_f[cnt].state = 7;
2422 }
2423 } else if (j->cadence_f[cnt].state == 4 &&
2424 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2425 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2426 if (j->cadence_f[cnt].on3) {
2427 j->cadence_f[cnt].state = 5;
2428 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2429 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2430 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2431 } else {
2432 j->cadence_f[cnt].state = 7;
2433 }
2434 } else {
2435 j->cadence_f[cnt].state = 0;
2436 }
2437 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2438 if (j->cadence_f[cnt].state == 1) {
2439 if(!j->cadence_f[cnt].on1) {
2440 j->cadence_f[cnt].state = 7;
2441 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2442 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2443 if(j->cadence_f[cnt].off1) {
2444 j->cadence_f[cnt].state = 2;
2445 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2446 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2447 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2448 } else {
2449 j->cadence_f[cnt].state = 7;
2450 }
2451 } else {
2452 j->cadence_f[cnt].state = 0;
2453 }
2454 } else if (j->cadence_f[cnt].state == 3) {
2455 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2456 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2457 if(j->cadence_f[cnt].off2) {
2458 j->cadence_f[cnt].state = 4;
2459 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2460 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2461 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2462 } else {
2463 j->cadence_f[cnt].state = 7;
2464 }
2465 } else {
2466 j->cadence_f[cnt].state = 0;
2467 }
2468 } else if (j->cadence_f[cnt].state == 5) {
2469 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2470 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2471 if(j->cadence_f[cnt].off3) {
2472 j->cadence_f[cnt].state = 6;
2473 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2474 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2475 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2476 } else {
2477 j->cadence_f[cnt].state = 7;
2478 }
2479 } else {
2480 j->cadence_f[cnt].state = 0;
2481 }
2482 } else {
2483 j->cadence_f[cnt].state = 0;
2484 }
2485 } else {
2486 switch(j->cadence_f[cnt].state) {
2487 case 1:
2488 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2489 !j->cadence_f[cnt].off1 &&
2490 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2491 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2492 j->cadence_f[cnt].state = 7;
2493 }
2494 break;
2495 case 3:
2496 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2497 !j->cadence_f[cnt].off2 &&
2498 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2499 j->cadence_f[cnt].state = 7;
2500 }
2501 break;
2502 case 5:
2503 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2504 !j->cadence_f[cnt].off3) {
2505 j->cadence_f[cnt].state = 7;
2506 }
2507 break;
2508 }
2509 }
2510
2511 if (ixjdebug & 0x0040) {
2512 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2513 switch(j->cadence_f[cnt].state) {
2514 case 0:
2515 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2516 break;
2517 case 1:
2518 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2519 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2520 break;
2521 case 2:
2522 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2523 j->cadence_f[cnt].off1max);
2524 break;
2525 case 3:
2526 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2527 j->cadence_f[cnt].on2max);
2528 break;
2529 case 4:
2530 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2531 j->cadence_f[cnt].off2max);
2532 break;
2533 case 5:
2534 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2535 j->cadence_f[cnt].on3max);
2536 break;
2537 case 6:
2538 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2539 j->cadence_f[cnt].off3max);
2540 break;
2541 }
2542 }
2543 }
2544 if (j->cadence_f[cnt].state == 7) {
2545 j->cadence_f[cnt].state = 0;
2546 if (j->cadence_f[cnt].enable == 1)
2547 j->cadence_f[cnt].enable = 0;
2548 switch (cnt) {
2549 case 0:
2550 if(ixjdebug & 0x0020) {
2551 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2552 }
2553 j->ex.bits.fc0 = 1;
2554 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2555 break;
2556 case 1:
2557 if(ixjdebug & 0x0020) {
2558 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2559 }
2560 j->ex.bits.fc1 = 1;
2561 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2562 break;
2563 case 2:
2564 if(ixjdebug & 0x0020) {
2565 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2566 }
2567 j->ex.bits.fc2 = 1;
2568 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2569 break;
2570 case 3:
2571 if(ixjdebug & 0x0020) {
2572 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2573 }
2574 j->ex.bits.fc3 = 1;
2575 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2576 break;
2577 }
2578 }
2579 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2580 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2581 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2582 trg = 1;
2583 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2584 trg = 0;
2585 }
2586 switch (cnt) {
2587 case 0:
2588 if(ixjdebug & 0x0020) {
2589 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2590 }
2591 j->ex.bits.f0 = 1;
2592 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2593 break;
2594 case 1:
2595 if(ixjdebug & 0x0020) {
2596 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2597 }
2598 j->ex.bits.f1 = 1;
2599 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2600 break;
2601 case 2:
2602 if(ixjdebug & 0x0020) {
2603 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2604 }
2605 j->ex.bits.f2 = 1;
2606 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2607 break;
2608 case 3:
2609 if(ixjdebug & 0x0020) {
2610 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2611 }
2612 j->ex.bits.f3 = 1;
2613 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2614 break;
2615 }
2616 }
2617 }
2618 return 0;
2619 }
2620
2621 static int LineMonitor(IXJ *j)
2622 {
2623 if (j->dtmf_proc) {
2624 return -1;
2625 }
2626 j->dtmf_proc = 1;
2627
2628 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2629 return -1;
2630
2631 j->dtmf.bytes.high = j->ssr.high;
2632 j->dtmf.bytes.low = j->ssr.low;
2633 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2634 j->dtmf_state = 1;
2635 j->dtmf_current = j->dtmf.bits.digit;
2636 }
2637 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2638 {
2639 if(!j->cidcw_wait) {
2640 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2641 j->dtmf_wp++;
2642 if (j->dtmf_wp == 79)
2643 j->dtmf_wp = 0;
2644 j->ex.bits.dtmf_ready = 1;
2645 if(j->ex_sig.bits.dtmf_ready) {
2646 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2647 }
2648 }
2649 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2650 if(ixjdebug & 0x0020) {
2651 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2652 }
2653 j->flags.cidcw_ack = 1;
2654 }
2655 j->dtmf_state = 0;
2656 }
2657 j->dtmf_proc = 0;
2658
2659 return 0;
2660 }
2661
2662 /************************************************************************
2663 *
2664 * Functions to allow alaw <-> ulaw conversions.
2665 *
2666 ************************************************************************/
2667
2668 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2669 {
2670 static unsigned char table_ulaw2alaw[] =
2671 {
2672 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2673 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2674 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2675 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2676 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2677 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2678 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2679 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2680 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2681 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2682 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2683 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2684 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2685 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2686 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2687 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2688 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2689 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2690 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2691 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2692 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2693 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2694 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2695 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2696 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2697 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2698 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2699 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2700 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2701 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2702 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2703 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2704 };
2705
2706 while (len--)
2707 {
2708 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2709 buff++;
2710 }
2711 }
2712
2713 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2714 {
2715 static unsigned char table_alaw2ulaw[] =
2716 {
2717 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2718 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2719 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2720 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2721 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2722 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2723 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2724 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2725 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2726 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2727 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2728 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2729 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2730 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2731 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2732 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2733 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2734 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2735 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2736 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2737 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2738 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2739 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2740 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2741 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2742 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2743 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2744 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2745 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2746 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2747 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2748 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2749 };
2750
2751 while (len--)
2752 {
2753 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2754 buff++;
2755 }
2756 }
2757
2758 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2759 {
2760 unsigned long i = *ppos;
2761 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2762
2763 DECLARE_WAITQUEUE(wait, current);
2764
2765 if (j->flags.inread)
2766 return -EALREADY;
2767
2768 j->flags.inread = 1;
2769
2770 add_wait_queue(&j->read_q, &wait);
2771 set_current_state(TASK_INTERRUPTIBLE);
2772 mb();
2773
2774 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2775 ++j->read_wait;
2776 if (file_p->f_flags & O_NONBLOCK) {
2777 set_current_state(TASK_RUNNING);
2778 remove_wait_queue(&j->read_q, &wait);
2779 j->flags.inread = 0;
2780 return -EAGAIN;
2781 }
2782 if (!ixj_hookstate(j)) {
2783 set_current_state(TASK_RUNNING);
2784 remove_wait_queue(&j->read_q, &wait);
2785 j->flags.inread = 0;
2786 return 0;
2787 }
2788 interruptible_sleep_on(&j->read_q);
2789 if (signal_pending(current)) {
2790 set_current_state(TASK_RUNNING);
2791 remove_wait_queue(&j->read_q, &wait);
2792 j->flags.inread = 0;
2793 return -EINTR;
2794 }
2795 }
2796
2797 remove_wait_queue(&j->read_q, &wait);
2798 set_current_state(TASK_RUNNING);
2799 /* Don't ever copy more than the user asks */
2800 if(j->rec_codec == ALAW)
2801 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2802 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2803 j->read_buffer_ready = 0;
2804 if (i) {
2805 j->flags.inread = 0;
2806 return -EFAULT;
2807 } else {
2808 j->flags.inread = 0;
2809 return min(length, j->read_buffer_size);
2810 }
2811 }
2812
2813 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2814 loff_t * ppos)
2815 {
2816 int pre_retval;
2817 ssize_t read_retval = 0;
2818 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2819
2820 pre_retval = ixj_PreRead(j, 0L);
2821 switch (pre_retval) {
2822 case NORMAL:
2823 read_retval = ixj_read(file_p, buf, length, ppos);
2824 ixj_PostRead(j, 0L);
2825 break;
2826 case NOPOST:
2827 read_retval = ixj_read(file_p, buf, length, ppos);
2828 break;
2829 case POSTONLY:
2830 ixj_PostRead(j, 0L);
2831 break;
2832 default:
2833 read_retval = pre_retval;
2834 }
2835 return read_retval;
2836 }
2837
2838 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2839 {
2840 unsigned long i = *ppos;
2841 IXJ *j = file_p->private_data;
2842
2843 DECLARE_WAITQUEUE(wait, current);
2844
2845 if (j->flags.inwrite)
2846 return -EALREADY;
2847
2848 j->flags.inwrite = 1;
2849
2850 add_wait_queue(&j->write_q, &wait);
2851 set_current_state(TASK_INTERRUPTIBLE);
2852 mb();
2853
2854
2855 while (!j->write_buffers_empty) {
2856 ++j->write_wait;
2857 if (file_p->f_flags & O_NONBLOCK) {
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 j->flags.inwrite = 0;
2861 return -EAGAIN;
2862 }
2863 if (!ixj_hookstate(j)) {
2864 set_current_state(TASK_RUNNING);
2865 remove_wait_queue(&j->write_q, &wait);
2866 j->flags.inwrite = 0;
2867 return 0;
2868 }
2869 interruptible_sleep_on(&j->write_q);
2870 if (signal_pending(current)) {
2871 set_current_state(TASK_RUNNING);
2872 remove_wait_queue(&j->write_q, &wait);
2873 j->flags.inwrite = 0;
2874 return -EINTR;
2875 }
2876 }
2877 set_current_state(TASK_RUNNING);
2878 remove_wait_queue(&j->write_q, &wait);
2879 if (j->write_buffer_wp + count >= j->write_buffer_end)
2880 j->write_buffer_wp = j->write_buffer;
2881 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2882 if (i) {
2883 j->flags.inwrite = 0;
2884 return -EFAULT;
2885 }
2886 if(j->play_codec == ALAW)
2887 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2888 j->flags.inwrite = 0;
2889 return min(count, j->write_buffer_size);
2890 }
2891
2892 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2893 {
2894 int pre_retval;
2895 ssize_t write_retval = 0;
2896
2897 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2898
2899 pre_retval = ixj_PreWrite(j, 0L);
2900 switch (pre_retval) {
2901 case NORMAL:
2902 write_retval = ixj_write(file_p, buf, count, ppos);
2903 if (write_retval > 0) {
2904 ixj_PostWrite(j, 0L);
2905 j->write_buffer_wp += write_retval;
2906 j->write_buffers_empty--;
2907 }
2908 break;
2909 case NOPOST:
2910 write_retval = ixj_write(file_p, buf, count, ppos);
2911 if (write_retval > 0) {
2912 j->write_buffer_wp += write_retval;
2913 j->write_buffers_empty--;
2914 }
2915 break;
2916 case POSTONLY:
2917 ixj_PostWrite(j, 0L);
2918 break;
2919 default:
2920 write_retval = pre_retval;
2921 }
2922 return write_retval;
2923 }
2924
2925 static void ixj_read_frame(IXJ *j)
2926 {
2927 int cnt, dly;
2928
2929 if (j->read_buffer) {
2930 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2931 if (!(cnt % 16) && !IsRxReady(j)) {
2932 dly = 0;
2933 while (!IsRxReady(j)) {
2934 if (dly++ > 5) {
2935 dly = 0;
2936 break;
2937 }
2938 udelay(10);
2939 }
2940 }
2941 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2942 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2943 inb_p(j->DSPbase + 0x0E);
2944 inb_p(j->DSPbase + 0x0F);
2945 }
2946 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2947 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2948 }
2949 ++j->framesread;
2950 if (j->intercom != -1) {
2951 if (IsTxReady(get_ixj(j->intercom))) {
2952 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2953 if (!(cnt % 16) && !IsTxReady(j)) {
2954 dly = 0;
2955 while (!IsTxReady(j)) {
2956 if (dly++ > 5) {
2957 dly = 0;
2958 break;
2959 }
2960 udelay(10);
2961 }
2962 }
2963 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2964 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2965 }
2966 get_ixj(j->intercom)->frameswritten++;
2967 }
2968 } else {
2969 j->read_buffer_ready = 1;
2970 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2971
2972 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2973
2974 if(j->ixj_signals[SIG_READ_READY])
2975 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2976 }
2977 }
2978 }
2979
2980 static short fsk[][6][20] =
2981 {
2982 {
2983 {
2984 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2985 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2986 },
2987 {
2988 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2989 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2990 },
2991 {
2992 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2993 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2994 },
2995 {
2996 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2997 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2998 },
2999 {
3000 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3001 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3002 },
3003 {
3004 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3005 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3006 }
3007 },
3008 {
3009 {
3010 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3011 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3012 },
3013 {
3014 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3015 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3016 },
3017 {
3018 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3019 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3020 },
3021 {
3022 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3023 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3024 },
3025 {
3026 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3027 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3028 },
3029 {
3030 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3031 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3032 }
3033 }
3034 };
3035
3036
3037 static void ixj_write_cid_bit(IXJ *j, int bit)
3038 {
3039 while (j->fskcnt < 20) {
3040 if(j->fskdcnt < (j->fsksize - 1))
3041 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3042
3043 j->fskcnt += 3;
3044 }
3045 j->fskcnt %= 20;
3046
3047 if (!bit)
3048 j->fskz++;
3049 if (j->fskz >= 6)
3050 j->fskz = 0;
3051
3052 }
3053
3054 static void ixj_write_cid_byte(IXJ *j, char byte)
3055 {
3056 IXJ_CBYTE cb;
3057
3058 cb.cbyte = byte;
3059 ixj_write_cid_bit(j, 0);
3060 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3061 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3062 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3063 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3064 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3065 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3066 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3067 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3068 ixj_write_cid_bit(j, 1);
3069 }
3070
3071 static void ixj_write_cid_seize(IXJ *j)
3072 {
3073 int cnt;
3074
3075 for (cnt = 0; cnt < 150; cnt++) {
3076 ixj_write_cid_bit(j, 0);
3077 ixj_write_cid_bit(j, 1);
3078 }
3079 for (cnt = 0; cnt < 180; cnt++) {
3080 ixj_write_cid_bit(j, 1);
3081 }
3082 }
3083
3084 static void ixj_write_cidcw_seize(IXJ *j)
3085 {
3086 int cnt;
3087
3088 for (cnt = 0; cnt < 80; cnt++) {
3089 ixj_write_cid_bit(j, 1);
3090 }
3091 }
3092
3093 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3094 {
3095 int cnt;
3096
3097 for (cnt = 0; cnt < strlen(s); cnt++) {
3098 ixj_write_cid_byte(j, s[cnt]);
3099 checksum = (checksum + s[cnt]);
3100 }
3101 return checksum;
3102 }
3103
3104 static void ixj_pad_fsk(IXJ *j, int pad)
3105 {
3106 int cnt;
3107
3108 for (cnt = 0; cnt < pad; cnt++) {
3109 if(j->fskdcnt < (j->fsksize - 1))
3110 j->fskdata[j->fskdcnt++] = 0x0000;
3111 }
3112 for (cnt = 0; cnt < 720; cnt++) {
3113 if(j->fskdcnt < (j->fsksize - 1))
3114 j->fskdata[j->fskdcnt++] = 0x0000;
3115 }
3116 }
3117
3118 static void ixj_pre_cid(IXJ *j)
3119 {
3120 j->cid_play_codec = j->play_codec;
3121 j->cid_play_frame_size = j->play_frame_size;
3122 j->cid_play_volume = get_play_volume(j);
3123 j->cid_play_flag = j->flags.playing;
3124
3125 j->cid_rec_codec = j->rec_codec;
3126 j->cid_rec_volume = get_rec_volume(j);
3127 j->cid_rec_flag = j->flags.recording;
3128
3129 j->cid_play_aec_level = j->aec_level;
3130
3131 switch(j->baseframe.low) {
3132 case 0xA0:
3133 j->cid_base_frame_size = 20;
3134 break;
3135 case 0x50:
3136 j->cid_base_frame_size = 10;
3137 break;
3138 case 0xF0:
3139 j->cid_base_frame_size = 30;
3140 break;
3141 }
3142
3143 ixj_play_stop(j);
3144 ixj_cpt_stop(j);
3145
3146 j->flags.cidplay = 1;
3147
3148 set_base_frame(j, 30);
3149 set_play_codec(j, LINEAR16);
3150 set_play_volume(j, 0x1B);
3151 ixj_play_start(j);
3152 }
3153
3154 static void ixj_post_cid(IXJ *j)
3155 {
3156 ixj_play_stop(j);
3157
3158 if(j->cidsize > 5000) {
3159 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3160 }
3161 j->flags.cidplay = 0;
3162 if(ixjdebug & 0x0200) {
3163 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3164 }
3165
3166 ixj_fsk_free(j);
3167
3168 j->fskdcnt = 0;
3169 set_base_frame(j, j->cid_base_frame_size);
3170 set_play_codec(j, j->cid_play_codec);
3171 ixj_aec_start(j, j->cid_play_aec_level);
3172 set_play_volume(j, j->cid_play_volume);
3173
3174 set_rec_codec(j, j->cid_rec_codec);
3175 set_rec_volume(j, j->cid_rec_volume);
3176
3177 if(j->cid_rec_flag)
3178 ixj_record_start(j);
3179
3180 if(j->cid_play_flag)
3181 ixj_play_start(j);
3182
3183 if(j->cid_play_flag) {
3184 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3185 }
3186 }
3187
3188 static void ixj_write_cid(IXJ *j)
3189 {
3190 char sdmf1[50];
3191 char sdmf2[50];
3192 char sdmf3[80];
3193 char mdmflen, len1, len2, len3;
3194 int pad;
3195
3196 int checksum = 0;
3197
3198 if (j->dsp.low == 0x20 || j->flags.cidplay)
3199 return;
3200
3201 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3202 j->cidsize = j->cidcnt = 0;
3203
3204 ixj_fsk_alloc(j);
3205
3206 strcpy(sdmf1, j->cid_send.month);
3207 strcat(sdmf1, j->cid_send.day);
3208 strcat(sdmf1, j->cid_send.hour);
3209 strcat(sdmf1, j->cid_send.min);
3210 strcpy(sdmf2, j->cid_send.number);
3211 strcpy(sdmf3, j->cid_send.name);
3212
3213 len1 = strlen(sdmf1);
3214 len2 = strlen(sdmf2);
3215 len3 = strlen(sdmf3);
3216 mdmflen = len1 + len2 + len3 + 6;
3217
3218 while(1){
3219 ixj_write_cid_seize(j);
3220
3221 ixj_write_cid_byte(j, 0x80);
3222 checksum = 0x80;
3223 ixj_write_cid_byte(j, mdmflen);
3224 checksum = checksum + mdmflen;
3225
3226 ixj_write_cid_byte(j, 0x01);
3227 checksum = checksum + 0x01;
3228 ixj_write_cid_byte(j, len1);
3229 checksum = checksum + len1;
3230 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3231 if(ixj_hookstate(j) & 1)
3232 break;
3233
3234 ixj_write_cid_byte(j, 0x02);
3235 checksum = checksum + 0x02;
3236 ixj_write_cid_byte(j, len2);
3237 checksum = checksum + len2;
3238 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3239 if(ixj_hookstate(j) & 1)
3240 break;
3241
3242 ixj_write_cid_byte(j, 0x07);
3243 checksum = checksum + 0x07;
3244 ixj_write_cid_byte(j, len3);
3245 checksum = checksum + len3;
3246 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3247 if(ixj_hookstate(j) & 1)
3248 break;
3249
3250 checksum %= 256;
3251 checksum ^= 0xFF;
3252 checksum += 1;
3253
3254 ixj_write_cid_byte(j, (char) checksum);
3255
3256 pad = j->fskdcnt % 240;
3257 if (pad) {
3258 pad = 240 - pad;
3259 }
3260 ixj_pad_fsk(j, pad);
3261 break;
3262 }
3263
3264 ixj_write_frame(j);
3265 }
3266
3267 static void ixj_write_cidcw(IXJ *j)
3268 {
3269 IXJ_TONE ti;
3270
3271 char sdmf1[50];
3272 char sdmf2[50];
3273 char sdmf3[80];
3274 char mdmflen, len1, len2, len3;
3275 int pad;
3276
3277 int checksum = 0;
3278
3279 if (j->dsp.low == 0x20 || j->flags.cidplay)
3280 return;
3281
3282 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3283 j->cidsize = j->cidcnt = 0;
3284
3285 ixj_fsk_alloc(j);
3286
3287 j->flags.cidcw_ack = 0;
3288
3289 ti.tone_index = 23;
3290 ti.gain0 = 1;
3291 ti.freq0 = hz440;
3292 ti.gain1 = 0;
3293 ti.freq1 = 0;
3294 ixj_init_tone(j, &ti);
3295
3296 ixj_set_tone_on(1500, j);
3297 ixj_set_tone_off(32, j);
3298 if(ixjdebug & 0x0200) {
3299 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3300 }
3301 ixj_play_tone(j, 23);
3302
3303 clear_bit(j->board, &j->busyflags);
3304 while(j->tone_state) {
3305 set_current_state(TASK_INTERRUPTIBLE);
3306 schedule_timeout(1);
3307 }
3308 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3309 set_current_state(TASK_INTERRUPTIBLE);
3310 schedule_timeout(1);
3311 }
3312 if(ixjdebug & 0x0200) {
3313 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3314 }
3315
3316 ti.tone_index = 24;
3317 ti.gain0 = 1;
3318 ti.freq0 = hz2130;
3319 ti.gain1 = 0;
3320 ti.freq1 = hz2750;
3321 ixj_init_tone(j, &ti);
3322
3323 ixj_set_tone_off(10, j);
3324 ixj_set_tone_on(600, j);
3325 if(ixjdebug & 0x0200) {
3326 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3327 }
3328 ixj_play_tone(j, 24);
3329
3330 clear_bit(j->board, &j->busyflags);
3331 while(j->tone_state) {
3332 set_current_state(TASK_INTERRUPTIBLE);
3333 schedule_timeout(1);
3334 }
3335 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3336 set_current_state(TASK_INTERRUPTIBLE);
3337 schedule_timeout(1);
3338 }
3339 if(ixjdebug & 0x0200) {
3340 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3341 }
3342
3343 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3344
3345 clear_bit(j->board, &j->busyflags);
3346 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3347 set_current_state(TASK_INTERRUPTIBLE);
3348 schedule_timeout(1);
3349 }
3350 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3351 set_current_state(TASK_INTERRUPTIBLE);
3352 schedule_timeout(1);
3353 }
3354 j->cidcw_wait = 0;
3355 if(!j->flags.cidcw_ack) {
3356 if(ixjdebug & 0x0200) {
3357 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3358 }
3359 ixj_post_cid(j);
3360 if(j->cid_play_flag) {
3361 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3362 }
3363 return;
3364 } else {
3365 ixj_pre_cid(j);
3366 }
3367 j->flags.cidcw_ack = 0;
3368 strcpy(sdmf1, j->cid_send.month);
3369 strcat(sdmf1, j->cid_send.day);
3370 strcat(sdmf1, j->cid_send.hour);
3371 strcat(sdmf1, j->cid_send.min);
3372 strcpy(sdmf2, j->cid_send.number);
3373 strcpy(sdmf3, j->cid_send.name);
3374
3375 len1 = strlen(sdmf1);
3376 len2 = strlen(sdmf2);
3377 len3 = strlen(sdmf3);
3378 mdmflen = len1 + len2 + len3 + 6;
3379
3380 ixj_write_cidcw_seize(j);
3381
3382 ixj_write_cid_byte(j, 0x80);
3383 checksum = 0x80;
3384 ixj_write_cid_byte(j, mdmflen);
3385 checksum = checksum + mdmflen;
3386
3387 ixj_write_cid_byte(j, 0x01);
3388 checksum = checksum + 0x01;
3389 ixj_write_cid_byte(j, len1);
3390 checksum = checksum + len1;
3391 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3392
3393 ixj_write_cid_byte(j, 0x02);
3394 checksum = checksum + 0x02;
3395 ixj_write_cid_byte(j, len2);
3396 checksum = checksum + len2;
3397 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3398
3399 ixj_write_cid_byte(j, 0x07);
3400 checksum = checksum + 0x07;
3401 ixj_write_cid_byte(j, len3);
3402 checksum = checksum + len3;
3403 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3404
3405 checksum %= 256;
3406 checksum ^= 0xFF;
3407 checksum += 1;
3408
3409 ixj_write_cid_byte(j, (char) checksum);
3410
3411 pad = j->fskdcnt % 240;
3412 if (pad) {
3413 pad = 240 - pad;
3414 }
3415 ixj_pad_fsk(j, pad);
3416 if(ixjdebug & 0x0200) {
3417 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3418 }
3419 }
3420
3421 static void ixj_write_vmwi(IXJ *j, int msg)
3422 {
3423 char mdmflen;
3424 int pad;
3425
3426 int checksum = 0;
3427
3428 if (j->dsp.low == 0x20 || j->flags.cidplay)
3429 return;
3430
3431 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3432 j->cidsize = j->cidcnt = 0;
3433
3434 ixj_fsk_alloc(j);
3435
3436 mdmflen = 3;
3437
3438 if (j->port == PORT_POTS)
3439 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3440
3441 ixj_write_cid_seize(j);
3442
3443 ixj_write_cid_byte(j, 0x82);
3444 checksum = 0x82;
3445 ixj_write_cid_byte(j, mdmflen);
3446 checksum = checksum + mdmflen;
3447
3448 ixj_write_cid_byte(j, 0x0B);
3449 checksum = checksum + 0x0B;
3450 ixj_write_cid_byte(j, 1);
3451 checksum = checksum + 1;
3452
3453 if(msg) {
3454 ixj_write_cid_byte(j, 0xFF);
3455 checksum = checksum + 0xFF;
3456 }
3457 else {
3458 ixj_write_cid_byte(j, 0x00);
3459 checksum = checksum + 0x00;
3460 }
3461
3462 checksum %= 256;
3463 checksum ^= 0xFF;
3464 checksum += 1;
3465
3466 ixj_write_cid_byte(j, (char) checksum);
3467
3468 pad = j->fskdcnt % 240;
3469 if (pad) {
3470 pad = 240 - pad;
3471 }
3472 ixj_pad_fsk(j, pad);
3473 }
3474
3475 static void ixj_write_frame(IXJ *j)
3476 {
3477 int cnt, frame_count, dly;
3478 IXJ_WORD dat;
3479 BYTES blankword;
3480
3481 frame_count = 0;
3482 if(j->flags.cidplay) {
3483 for(cnt = 0; cnt < 480; cnt++) {
3484 if (!(cnt % 16) && !IsTxReady(j)) {
3485 dly = 0;
3486 while (!IsTxReady(j)) {
3487 if (dly++ > 5) {
3488 dly = 0;
3489 break;
3490 }
3491 udelay(10);
3492 }
3493 }
3494 dat.word = j->fskdata[j->cidcnt++];
3495 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3496 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3497 cnt++;
3498 }
3499 if(j->cidcnt >= j->fskdcnt) {
3500 ixj_post_cid(j);
3501 }
3502 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3503 and there is real audio data in the buffer, we need to throw it away because
3504 we just used it's time slot */
3505 if (j->write_buffer_rp > j->write_buffer_wp) {
3506 j->write_buffer_rp += j->cid_play_frame_size * 2;
3507 if (j->write_buffer_rp >= j->write_buffer_end) {
3508 j->write_buffer_rp = j->write_buffer;
3509 }
3510 j->write_buffers_empty++;
3511 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3512
3513 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3514 }
3515 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3516 if (j->write_buffer_wp > j->write_buffer_rp) {
3517 frame_count =
3518 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3519 }
3520 if (j->write_buffer_rp > j->write_buffer_wp) {
3521 frame_count =
3522 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3523 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3524 }
3525 if (frame_count >= 1) {
3526 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3527 switch (j->play_mode) {
3528 case PLAYBACK_MODE_ULAW:
3529 case PLAYBACK_MODE_ALAW:
3530 blankword.low = blankword.high = 0xFF;
3531 break;
3532 case PLAYBACK_MODE_8LINEAR:
3533 case PLAYBACK_MODE_16LINEAR:
3534 blankword.low = blankword.high = 0x00;
3535 break;
3536 case PLAYBACK_MODE_8LINEAR_WSS:
3537 blankword.low = blankword.high = 0x80;
3538 break;
3539 }
3540 for (cnt = 0; cnt < 16; cnt++) {
3541 if (!(cnt % 16) && !IsTxReady(j)) {
3542 dly = 0;
3543 while (!IsTxReady(j)) {
3544 if (dly++ > 5) {
3545 dly = 0;
3546 break;
3547 }
3548 udelay(10);
3549 }
3550 }
3551 outb_p((blankword.low), j->DSPbase + 0x0C);
3552 outb_p((blankword.high), j->DSPbase + 0x0D);
3553 }
3554 j->flags.play_first_frame = 0;
3555 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3556 for (cnt = 0; cnt < 24; cnt++) {
3557 if(cnt == 12) {
3558 blankword.low = 0x02;
3559 blankword.high = 0x00;
3560 }
3561 else {
3562 blankword.low = blankword.high = 0x00;
3563 }
3564 if (!(cnt % 16) && !IsTxReady(j)) {
3565 dly = 0;
3566 while (!IsTxReady(j)) {
3567 if (dly++ > 5) {
3568 dly = 0;
3569 break;
3570 }
3571 udelay(10);
3572 }
3573 }
3574 outb_p((blankword.low), j->DSPbase + 0x0C);
3575 outb_p((blankword.high), j->DSPbase + 0x0D);
3576 }
3577 j->flags.play_first_frame = 0;
3578 }
3579 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3580 if (!(cnt % 16) && !IsTxReady(j)) {
3581 dly = 0;
3582 while (!IsTxReady(j)) {
3583 if (dly++ > 5) {
3584 dly = 0;
3585 break;
3586 }
3587 udelay(10);
3588 }
3589 }
3590 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3591 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3592 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3593 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3594 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3595 j->write_buffer_rp + cnt + 9 == 0) {
3596 /* someone is trying to write silence lets make this a type 0 frame. */
3597 outb_p(0x00, j->DSPbase + 0x0C);
3598 outb_p(0x00, j->DSPbase + 0x0D);
3599 } else {
3600 /* so all other frames are type 1. */
3601 outb_p(0x01, j->DSPbase + 0x0C);
3602 outb_p(0x00, j->DSPbase + 0x0D);
3603 }
3604 }
3605 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3606 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3607 *(j->write_buffer_rp + cnt) = 0;
3608 *(j->write_buffer_rp + cnt + 1) = 0;
3609 }
3610 j->write_buffer_rp += j->play_frame_size * 2;
3611 if (j->write_buffer_rp >= j->write_buffer_end) {
3612 j->write_buffer_rp = j->write_buffer;
3613 }
3614 j->write_buffers_empty++;
3615 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3616
3617 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3618
3619 ++j->frameswritten;
3620 }
3621 } else {
3622 j->drybuffer++;
3623 }
3624 if(j->ixj_signals[SIG_WRITE_READY]) {
3625 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3626 }
3627 }
3628
3629 static int idle(IXJ *j)
3630 {
3631 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3632
3633 return 0;
3634
3635 if (j->ssr.high || j->ssr.low) {
3636 return 0;
3637 } else {
3638 j->play_mode = -1;
3639 j->flags.playing = 0;
3640 j->rec_mode = -1;
3641 j->flags.recording = 0;
3642 return 1;
3643 }
3644 }
3645
3646 static int set_base_frame(IXJ *j, int size)
3647 {
3648 unsigned short cmd;
3649 int cnt;
3650
3651 idle(j);
3652 j->cid_play_aec_level = j->aec_level;
3653 aec_stop(j);
3654 for (cnt = 0; cnt < 10; cnt++) {
3655 if (idle(j))
3656 break;
3657 }
3658 if (j->ssr.high || j->ssr.low)
3659 return -1;
3660 if (j->dsp.low != 0x20) {
3661 switch (size) {
3662 case 30:
3663 cmd = 0x07F0;
3664 /* Set Base Frame Size to 240 pg9-10 8021 */
3665 break;
3666 case 20:
3667 cmd = 0x07A0;
3668 /* Set Base Frame Size to 160 pg9-10 8021 */
3669 break;
3670 case 10:
3671 cmd = 0x0750;
3672 /* Set Base Frame Size to 80 pg9-10 8021 */
3673 break;
3674 default:
3675 return -1;
3676 }
3677 } else {
3678 if (size == 30)
3679 return size;
3680 else
3681 return -1;
3682 }
3683 if (ixj_WriteDSPCommand(cmd, j)) {
3684 j->baseframe.high = j->baseframe.low = 0xFF;
3685 return -1;
3686 } else {
3687 j->baseframe.high = j->ssr.high;
3688 j->baseframe.low = j->ssr.low;
3689 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3690 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3691 return -1;
3692 }
3693 }
3694 ixj_aec_start(j, j->cid_play_aec_level);
3695 return size;
3696 }
3697
3698 static int set_rec_codec(IXJ *j, int rate)
3699 {
3700 int retval = 0;
3701
3702 j->rec_codec = rate;
3703
3704 switch (rate) {
3705 case G723_63:
3706 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3707 j->rec_frame_size = 12;
3708 j->rec_mode = 0;
3709 } else {
3710 retval = 1;
3711 }
3712 break;
3713 case G723_53:
3714 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3715 j->rec_frame_size = 10;
3716 j->rec_mode = 0;
3717 } else {
3718 retval = 1;
3719 }
3720 break;
3721 case TS85:
3722 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3723 j->rec_frame_size = 16;
3724 j->rec_mode = 0;
3725 } else {
3726 retval = 1;
3727 }
3728 break;
3729 case TS48:
3730 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3731 j->rec_frame_size = 9;
3732 j->rec_mode = 0;
3733 } else {
3734 retval = 1;
3735 }
3736 break;
3737 case TS41:
3738 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3739 j->rec_frame_size = 8;
3740 j->rec_mode = 0;
3741 } else {
3742 retval = 1;
3743 }
3744 break;
3745 case G728:
3746 if (j->dsp.low != 0x20) {
3747 j->rec_frame_size = 48;
3748 j->rec_mode = 0;
3749 } else {
3750 retval = 1;
3751 }
3752 break;
3753 case G729:
3754 if (j->dsp.low != 0x20) {
3755 if (!j->flags.g729_loaded) {
3756 retval = 1;
3757 break;
3758 }
3759 switch (j->baseframe.low) {
3760 case 0xA0:
3761 j->rec_frame_size = 10;
3762 break;
3763 case 0x50:
3764 j->rec_frame_size = 5;
3765 break;
3766 default:
3767 j->rec_frame_size = 15;
3768 break;
3769 }
3770 j->rec_mode = 0;
3771 } else {
3772 retval = 1;
3773 }
3774 break;
3775 case G729B:
3776 if (j->dsp.low != 0x20) {
3777 if (!j->flags.g729_loaded) {
3778 retval = 1;
3779 break;
3780 }
3781 switch (j->baseframe.low) {
3782 case 0xA0:
3783 j->rec_frame_size = 12;
3784 break;
3785 case 0x50:
3786 j->rec_frame_size = 6;
3787 break;
3788 default:
3789 j->rec_frame_size = 18;
3790 break;
3791 }
3792 j->rec_mode = 0;
3793 } else {
3794 retval = 1;
3795 }
3796 break;
3797 case ULAW:
3798 switch (j->baseframe.low) {
3799 case 0xA0:
3800 j->rec_frame_size = 80;
3801 break;
3802 case 0x50:
3803 j->rec_frame_size = 40;
3804 break;
3805 default:
3806 j->rec_frame_size = 120;
3807 break;
3808 }
3809 j->rec_mode = 4;
3810 break;
3811 case ALAW:
3812 switch (j->baseframe.low) {
3813 case 0xA0:
3814 j->rec_frame_size = 80;
3815 break;
3816 case 0x50:
3817 j->rec_frame_size = 40;
3818 break;
3819 default:
3820 j->rec_frame_size = 120;
3821 break;
3822 }
3823 j->rec_mode = 4;
3824 break;
3825 case LINEAR16:
3826 switch (j->baseframe.low) {
3827 case 0xA0:
3828 j->rec_frame_size = 160;
3829 break;
3830 case 0x50:
3831 j->rec_frame_size = 80;
3832 break;
3833 default:
3834 j->rec_frame_size = 240;
3835 break;
3836 }
3837 j->rec_mode = 5;
3838 break;
3839 case LINEAR8:
3840 switch (j->baseframe.low) {
3841 case 0xA0:
3842 j->rec_frame_size = 80;
3843 break;
3844 case 0x50:
3845 j->rec_frame_size = 40;
3846 break;
3847 default:
3848 j->rec_frame_size = 120;
3849 break;
3850 }
3851 j->rec_mode = 6;
3852 break;
3853 case WSS:
3854 switch (j->baseframe.low) {
3855 case 0xA0:
3856 j->rec_frame_size = 80;
3857 break;
3858 case 0x50:
3859 j->rec_frame_size = 40;
3860 break;
3861 default:
3862 j->rec_frame_size = 120;
3863 break;
3864 }
3865 j->rec_mode = 7;
3866 break;
3867 default:
3868 kfree(j->read_buffer);
3869 j->rec_frame_size = 0;
3870 j->rec_mode = -1;
3871 j->read_buffer = NULL;
3872 j->read_buffer_size = 0;
3873 retval = 1;
3874 break;
3875 }
3876 return retval;
3877 }
3878
3879 static int ixj_record_start(IXJ *j)
3880 {
3881 unsigned short cmd = 0x0000;
3882
3883 if (j->read_buffer) {
3884 ixj_record_stop(j);
3885 }
3886 j->flags.recording = 1;
3887 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3888
3889 if(ixjdebug & 0x0002)
3890 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3891
3892 if (!j->rec_mode) {
3893 switch (j->rec_codec) {
3894 case G723_63:
3895 cmd = 0x5131;
3896 break;
3897 case G723_53:
3898 cmd = 0x5132;
3899 break;
3900 case TS85:
3901 cmd = 0x5130; /* TrueSpeech 8.5 */
3902
3903 break;
3904 case TS48:
3905 cmd = 0x5133; /* TrueSpeech 4.8 */
3906
3907 break;
3908 case TS41:
3909 cmd = 0x5134; /* TrueSpeech 4.1 */
3910
3911 break;
3912 case G728:
3913 cmd = 0x5135;
3914 break;
3915 case G729:
3916 case G729B:
3917 cmd = 0x5136;
3918 break;
3919 default:
3920 return 1;
3921 }
3922 if (ixj_WriteDSPCommand(cmd, j))
3923 return -1;
3924 }
3925 if (!j->read_buffer) {
3926 if (!j->read_buffer)
3927 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3928 if (!j->read_buffer) {
3929 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3930 return -ENOMEM;
3931 }
3932 }
3933 j->read_buffer_size = j->rec_frame_size * 2;
3934
3935 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3936
3937 return -1;
3938
3939 switch (j->rec_mode) {
3940 case 0:
3941 cmd = 0x1C03; /* Record C1 */
3942
3943 break;
3944 case 4:
3945 if (j->ver.low == 0x12) {
3946 cmd = 0x1E03; /* Record C1 */
3947
3948 } else {
3949 cmd = 0x1E01; /* Record C1 */
3950
3951 }
3952 break;
3953 case 5:
3954 if (j->ver.low == 0x12) {
3955 cmd = 0x1E83; /* Record C1 */
3956
3957 } else {
3958 cmd = 0x1E81; /* Record C1 */
3959
3960 }
3961 break;
3962 case 6:
3963 if (j->ver.low == 0x12) {
3964 cmd = 0x1F03; /* Record C1 */
3965
3966 } else {
3967 cmd = 0x1F01; /* Record C1 */
3968
3969 }
3970 break;
3971 case 7:
3972 if (j->ver.low == 0x12) {
3973 cmd = 0x1F83; /* Record C1 */
3974 } else {
3975 cmd = 0x1F81; /* Record C1 */
3976 }
3977 break;
3978 }
3979 if (ixj_WriteDSPCommand(cmd, j))
3980 return -1;
3981
3982 if (j->flags.playing) {
3983 ixj_aec_start(j, j->aec_level);
3984 }
3985 return 0;
3986 }
3987
3988 static void ixj_record_stop(IXJ *j)
3989 {
3990 if (ixjdebug & 0x0002)
3991 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3992
3993 kfree(j->read_buffer);
3994 j->read_buffer = NULL;
3995 j->read_buffer_size = 0;
3996 if (j->rec_mode > -1) {
3997 ixj_WriteDSPCommand(0x5120, j);
3998 j->rec_mode = -1;
3999 }
4000 j->flags.recording = 0;
4001 }
4002 static void ixj_vad(IXJ *j, int arg)
4003 {
4004 if (arg)
4005 ixj_WriteDSPCommand(0x513F, j);
4006 else
4007 ixj_WriteDSPCommand(0x513E, j);
4008 }
4009
4010 static void set_rec_depth(IXJ *j, int depth)
4011 {
4012 if (depth > 60)
4013 depth = 60;
4014 if (depth < 0)
4015 depth = 0;
4016 ixj_WriteDSPCommand(0x5180 + depth, j);
4017 }
4018
4019 static void set_dtmf_prescale(IXJ *j, int volume)
4020 {
4021 ixj_WriteDSPCommand(0xCF07, j);
4022 ixj_WriteDSPCommand(volume, j);
4023 }
4024
4025 static int get_dtmf_prescale(IXJ *j)
4026 {
4027 ixj_WriteDSPCommand(0xCF05, j);
4028 return j->ssr.high << 8 | j->ssr.low;
4029 }
4030
4031 static void set_rec_volume(IXJ *j, int volume)
4032 {
4033 if(j->aec_level == AEC_AGC) {
4034 if (ixjdebug & 0x0002)
4035 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4036 ixj_WriteDSPCommand(0xCF96, j);
4037 ixj_WriteDSPCommand(volume, j);
4038 } else {
4039 if (ixjdebug & 0x0002)
4040 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4041 ixj_WriteDSPCommand(0xCF03, j);
4042 ixj_WriteDSPCommand(volume, j);
4043 }
4044 }
4045
4046 static int set_rec_volume_linear(IXJ *j, int volume)
4047 {
4048 int newvolume, dsprecmax;
4049
4050 if (ixjdebug & 0x0002)
4051 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4052 if(volume > 100 || volume < 0) {
4053 return -1;
4054 }
4055
4056 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4057 switch (j->cardtype) {
4058 case QTI_PHONEJACK:
4059 dsprecmax = 0x440;
4060 break;
4061 case QTI_LINEJACK:
4062 dsprecmax = 0x180;
4063 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4064 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4065 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4066 break;
4067 case QTI_PHONEJACK_LITE:
4068 dsprecmax = 0x4C0;
4069 break;
4070 case QTI_PHONEJACK_PCI:
4071 dsprecmax = 0x100;
4072 break;
4073 case QTI_PHONECARD:
4074 dsprecmax = 0x400;
4075 break;
4076 default:
4077 return -1;
4078 }
4079 newvolume = (dsprecmax * volume) / 100;
4080 set_rec_volume(j, newvolume);
4081 return 0;
4082 }
4083
4084 static int get_rec_volume(IXJ *j)
4085 {
4086 if(j->aec_level == AEC_AGC) {
4087 if (ixjdebug & 0x0002)
4088 printk(KERN_INFO "Getting AGC Threshold\n");
4089 ixj_WriteDSPCommand(0xCF86, j);
4090 if (ixjdebug & 0x0002)
4091 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4092 return j->ssr.high << 8 | j->ssr.low;
4093 } else {
4094 if (ixjdebug & 0x0002)
4095 printk(KERN_INFO "Getting Record Volume\n");
4096 ixj_WriteDSPCommand(0xCF01, j);
4097 return j->ssr.high << 8 | j->ssr.low;
4098 }
4099 }
4100
4101 static int get_rec_volume_linear(IXJ *j)
4102 {
4103 int volume, newvolume, dsprecmax;
4104
4105 switch (j->cardtype) {
4106 case QTI_PHONEJACK:
4107 dsprecmax = 0x440;
4108 break;
4109 case QTI_LINEJACK:
4110 dsprecmax = 0x180;
4111 break;
4112 case QTI_PHONEJACK_LITE:
4113 dsprecmax = 0x4C0;
4114 break;
4115 case QTI_PHONEJACK_PCI:
4116 dsprecmax = 0x100;
4117 break;
4118 case QTI_PHONECARD:
4119 dsprecmax = 0x400;
4120 break;
4121 default:
4122 return -1;
4123 }
4124 volume = get_rec_volume(j);
4125 newvolume = (volume * 100) / dsprecmax;
4126 if(newvolume > 100)
4127 newvolume = 100;
4128 return newvolume;
4129 }
4130
4131 static int get_rec_level(IXJ *j)
4132 {
4133 int retval;
4134
4135 ixj_WriteDSPCommand(0xCF88, j);
4136
4137 retval = j->ssr.high << 8 | j->ssr.low;
4138 retval = (retval * 256) / 240;
4139 return retval;
4140 }
4141
4142 static void ixj_aec_start(IXJ *j, int level)
4143 {
4144 j->aec_level = level;
4145 if (ixjdebug & 0x0002)
4146 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4147 if (!level) {
4148 aec_stop(j);
4149 } else {
4150 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4151 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4152
4153 ixj_WriteDSPCommand(0x0300, j);
4154 }
4155 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4156
4157 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4158
4159 switch (level) {
4160 case AEC_LOW:
4161 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4162
4163 ixj_WriteDSPCommand(0xE011, j);
4164 ixj_WriteDSPCommand(0xFFFF, j);
4165
4166 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4167 ixj_WriteDSPCommand(0x0000, j); /* to off */
4168
4169 break;
4170
4171 case AEC_MED:
4172 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4173
4174 ixj_WriteDSPCommand(0xE011, j);
4175 ixj_WriteDSPCommand(0x0080, j);
4176
4177 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4178 ixj_WriteDSPCommand(0x0000, j); /* to off */
4179
4180 break;
4181
4182 case AEC_HIGH:
4183 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4184
4185 ixj_WriteDSPCommand(0xE011, j);
4186 ixj_WriteDSPCommand(0x0080, j);
4187
4188 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4189 ixj_WriteDSPCommand(0x0000, j); /* to off */
4190
4191 break;
4192
4193 case AEC_AGC:
4194 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4195 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4196
4197 ixj_WriteDSPCommand(0xE011, j);
4198 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4199
4200 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4201
4202 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4203 ixj_WriteDSPCommand(0x0224, j);
4204 else
4205 ixj_WriteDSPCommand(0x1224, j);
4206
4207 ixj_WriteDSPCommand(0xE014, j);
4208 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4209
4210 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4211
4212 /* Now we can set the AGC initial parameters and turn it on */
4213 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4214 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4215
4216 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4217 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4218
4219 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4220 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4221
4222 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4223 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4224
4225 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4226 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4227
4228 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4229 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4230
4231 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4232 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4233
4234 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4235 ixj_WriteDSPCommand(0x0001, j); /* to on */
4236
4237 break;
4238
4239 case AEC_AUTO:
4240 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4241
4242 ixj_WriteDSPCommand(0xE011, j);
4243 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4244
4245 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4246
4247 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4248 ixj_WriteDSPCommand(0x0224, j);
4249 else
4250 ixj_WriteDSPCommand(0x1224, j);
4251
4252 ixj_WriteDSPCommand(0xE014, j);
4253 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4254
4255 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4256
4257 break;
4258 }
4259 }
4260 }
4261
4262 static void aec_stop(IXJ *j)
4263 {
4264 j->aec_level = AEC_OFF;
4265 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4266 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4267
4268 ixj_WriteDSPCommand(0x0700, j);
4269 }
4270 if (j->play_mode != -1 && j->rec_mode != -1)
4271 {
4272 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4273 }
4274 }
4275
4276 static int set_play_codec(IXJ *j, int rate)
4277 {
4278 int retval = 0;
4279
4280 j->play_codec = rate;
4281
4282 switch (rate) {
4283 case G723_63:
4284 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4285 j->play_frame_size = 12;
4286 j->play_mode = 0;
4287 } else {
4288 retval = 1;
4289 }
4290 break;
4291 case G723_53:
4292 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4293 j->play_frame_size = 10;
4294 j->play_mode = 0;
4295 } else {
4296 retval = 1;
4297 }
4298 break;
4299 case TS85:
4300 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4301 j->play_frame_size = 16;
4302 j->play_mode = 0;
4303 } else {
4304 retval = 1;
4305 }
4306 break;
4307 case TS48:
4308 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4309 j->play_frame_size = 9;
4310 j->play_mode = 0;
4311 } else {
4312 retval = 1;
4313 }
4314 break;
4315 case TS41:
4316 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4317 j->play_frame_size = 8;
4318 j->play_mode = 0;
4319 } else {
4320 retval = 1;
4321 }
4322 break;
4323 case G728:
4324 if (j->dsp.low != 0x20) {
4325 j->play_frame_size = 48;
4326 j->play_mode = 0;
4327 } else {
4328 retval = 1;
4329 }
4330 break;
4331 case G729:
4332 if (j->dsp.low != 0x20) {
4333 if (!j->flags.g729_loaded) {
4334 retval = 1;
4335 break;
4336 }
4337 switch (j->baseframe.low) {
4338 case 0xA0:
4339 j->play_frame_size = 10;
4340 break;
4341 case 0x50:
4342 j->play_frame_size = 5;
4343 break;
4344 default:
4345 j->play_frame_size = 15;
4346 break;
4347 }
4348 j->play_mode = 0;
4349 } else {
4350 retval = 1;
4351 }
4352 break;
4353 case G729B:
4354 if (j->dsp.low != 0x20) {
4355 if (!j->flags.g729_loaded) {
4356 retval = 1;
4357 break;
4358 }
4359 switch (j->baseframe.low) {
4360 case 0xA0:
4361 j->play_frame_size = 12;
4362 break;
4363 case 0x50:
4364 j->play_frame_size = 6;
4365 break;
4366 default:
4367 j->play_frame_size = 18;
4368 break;
4369 }
4370 j->play_mode = 0;
4371 } else {
4372 retval = 1;
4373 }
4374 break;
4375 case ULAW:
4376 switch (j->baseframe.low) {
4377 case 0xA0:
4378 j->play_frame_size = 80;
4379 break;
4380 case 0x50:
4381 j->play_frame_size = 40;
4382 break;
4383 default:
4384 j->play_frame_size = 120;
4385 break;
4386 }
4387 j->play_mode = 2;
4388 break;
4389 case ALAW:
4390 switch (j->baseframe.low) {
4391 case 0xA0:
4392 j->play_frame_size = 80;
4393 break;
4394 case 0x50:
4395 j->play_frame_size = 40;
4396 break;
4397 default:
4398 j->play_frame_size = 120;
4399 break;
4400 }
4401 j->play_mode = 2;
4402 break;
4403 case LINEAR16:
4404 switch (j->baseframe.low) {
4405 case 0xA0:
4406 j->play_frame_size = 160;
4407 break;
4408 case 0x50:
4409 j->play_frame_size = 80;
4410 break;
4411 default:
4412 j->play_frame_size = 240;
4413 break;
4414 }
4415 j->play_mode = 6;
4416 break;
4417 case LINEAR8:
4418 switch (j->baseframe.low) {
4419 case 0xA0:
4420 j->play_frame_size = 80;
4421 break;
4422 case 0x50:
4423 j->play_frame_size = 40;
4424 break;
4425 default:
4426 j->play_frame_size = 120;
4427 break;
4428 }
4429 j->play_mode = 4;
4430 break;
4431 case WSS:
4432 switch (j->baseframe.low) {
4433 case 0xA0:
4434 j->play_frame_size = 80;
4435 break;
4436 case 0x50:
4437 j->play_frame_size = 40;
4438 break;
4439 default:
4440 j->play_frame_size = 120;
4441 break;
4442 }
4443 j->play_mode = 5;
4444 break;
4445 default:
4446 kfree(j->write_buffer);
4447 j->play_frame_size = 0;
4448 j->play_mode = -1;
4449 j->write_buffer = NULL;
4450 j->write_buffer_size = 0;
4451 retval = 1;
4452 break;
4453 }
4454 return retval;
4455 }
4456
4457 static int ixj_play_start(IXJ *j)
4458 {
4459 unsigned short cmd = 0x0000;
4460
4461 if (j->write_buffer) {
4462 ixj_play_stop(j);
4463 }
4464
4465 if(ixjdebug & 0x0002)
4466 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4467
4468 j->flags.playing = 1;
4469 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4470
4471 j->flags.play_first_frame = 1;
4472 j->drybuffer = 0;
4473
4474 if (!j->play_mode) {
4475 switch (j->play_codec) {
4476 case G723_63:
4477 cmd = 0x5231;
4478 break;
4479 case G723_53:
4480 cmd = 0x5232;
4481 break;
4482 case TS85:
4483 cmd = 0x5230; /* TrueSpeech 8.5 */
4484
4485 break;
4486 case TS48:
4487 cmd = 0x5233; /* TrueSpeech 4.8 */
4488
4489 break;
4490 case TS41:
4491 cmd = 0x5234; /* TrueSpeech 4.1 */
4492
4493 break;
4494 case G728:
4495 cmd = 0x5235;
4496 break;
4497 case G729:
4498 case G729B:
4499 cmd = 0x5236;
4500 break;
4501 default:
4502 return 1;
4503 }
4504 if (ixj_WriteDSPCommand(cmd, j))
4505 return -1;
4506 }
4507 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4508 if (!j->write_buffer) {
4509 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4510 return -ENOMEM;
4511 }
4512 /* j->write_buffers_empty = 2; */
4513 j->write_buffers_empty = 1;
4514 j->write_buffer_size = j->play_frame_size * 2;
4515 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4516 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4517
4518 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4519
4520 return -1;
4521
4522 switch (j->play_mode) {
4523 case 0:
4524 cmd = 0x2C03;
4525 break;
4526 case 2:
4527 if (j->ver.low == 0x12) {
4528 cmd = 0x2C23;
4529 } else {
4530 cmd = 0x2C21;
4531 }
4532 break;
4533 case 4:
4534 if (j->ver.low == 0x12) {
4535 cmd = 0x2C43;
4536 } else {
4537 cmd = 0x2C41;
4538 }
4539 break;
4540 case 5:
4541 if (j->ver.low == 0x12) {
4542 cmd = 0x2C53;
4543 } else {
4544 cmd = 0x2C51;
4545 }
4546 break;
4547 case 6:
4548 if (j->ver.low == 0x12) {
4549 cmd = 0x2C63;
4550 } else {
4551 cmd = 0x2C61;
4552 }
4553 break;
4554 }
4555 if (ixj_WriteDSPCommand(cmd, j))
4556 return -1;
4557
4558 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4559 return -1;
4560
4561 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4562 return -1;
4563
4564 if (j->flags.recording) {
4565 ixj_aec_start(j, j->aec_level);
4566 }
4567
4568 return 0;
4569 }
4570
4571 static void ixj_play_stop(IXJ *j)
4572 {
4573 if (ixjdebug & 0x0002)
4574 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4575
4576 kfree(j->write_buffer);
4577 j->write_buffer = NULL;
4578 j->write_buffer_size = 0;
4579 if (j->play_mode > -1) {
4580 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4581
4582 j->play_mode = -1;
4583 }
4584 j->flags.playing = 0;
4585 }
4586
4587 static inline int get_play_level(IXJ *j)
4588 {
4589 int retval;
4590
4591 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4592 return j->ssr.high << 8 | j->ssr.low;
4593 retval = j->ssr.high << 8 | j->ssr.low;
4594 retval = (retval * 256) / 240;
4595 return retval;
4596 }
4597
4598 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4599 {
4600 unsigned int mask = 0;
4601
4602 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4603
4604 poll_wait(file_p, &(j->poll_q), wait);
4605 if (j->read_buffer_ready > 0)
4606 mask |= POLLIN | POLLRDNORM; /* readable */
4607 if (j->write_buffers_empty > 0)
4608 mask |= POLLOUT | POLLWRNORM; /* writable */
4609 if (j->ex.bytes)
4610 mask |= POLLPRI;
4611 return mask;
4612 }
4613
4614 static int ixj_play_tone(IXJ *j, char tone)
4615 {
4616 if (!j->tone_state) {
4617 if(ixjdebug & 0x0002) {
4618 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4619 }
4620 if (j->dsp.low == 0x20) {
4621 idle(j);
4622 }
4623 j->tone_start_jif = jiffies;
4624
4625 j->tone_state = 1;
4626 }
4627
4628 j->tone_index = tone;
4629 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4630 return -1;
4631
4632 return 0;
4633 }
4634
4635 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4636 {
4637 j->tone_on_time = arg;
4638
4639 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4640
4641 return -1;
4642
4643 if (ixj_WriteDSPCommand(arg, j))
4644 return -1;
4645
4646 return 0;
4647 }
4648
4649 static int SCI_WaitHighSCI(IXJ *j)
4650 {
4651 int cnt;
4652
4653 j->pld_scrr.byte = inb_p(j->XILINXbase);
4654 if (!j->pld_scrr.bits.sci) {
4655 for (cnt = 0; cnt < 10; cnt++) {
4656 udelay(32);
4657 j->pld_scrr.byte = inb_p(j->XILINXbase);
4658
4659 if ((j->pld_scrr.bits.sci))
4660 return 1;
4661 }
4662 if (ixjdebug & 0x0001)
4663 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4664 return 0;
4665 } else
4666 return 1;
4667 }
4668
4669 static int SCI_WaitLowSCI(IXJ *j)
4670 {
4671 int cnt;
4672
4673 j->pld_scrr.byte = inb_p(j->XILINXbase);
4674 if (j->pld_scrr.bits.sci) {
4675 for (cnt = 0; cnt < 10; cnt++) {
4676 udelay(32);
4677 j->pld_scrr.byte = inb_p(j->XILINXbase);
4678
4679 if (!(j->pld_scrr.bits.sci))
4680 return 1;
4681 }
4682 if (ixjdebug & 0x0001)
4683 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4684 return 0;
4685 } else
4686 return 1;
4687 }
4688
4689 static int SCI_Control(IXJ *j, int control)
4690 {
4691 switch (control) {
4692 case SCI_End:
4693 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4694
4695 j->pld_scrw.bits.c1 = 0; /* to no selection */
4696
4697 break;
4698 case SCI_Enable_DAA:
4699 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4700
4701 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4702
4703 break;
4704 case SCI_Enable_Mixer:
4705 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4706
4707 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4708
4709 break;
4710 case SCI_Enable_EEPROM:
4711 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4712
4713 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4714
4715 break;
4716 default:
4717 return 0;
4718 break;
4719 }
4720 outb_p(j->pld_scrw.byte, j->XILINXbase);
4721
4722 switch (control) {
4723 case SCI_End:
4724 return 1;
4725 break;
4726 case SCI_Enable_DAA:
4727 case SCI_Enable_Mixer:
4728 case SCI_Enable_EEPROM:
4729 if (!SCI_WaitHighSCI(j))
4730 return 0;
4731 break;
4732 default:
4733 return 0;
4734 break;
4735 }
4736 return 1;
4737 }
4738
4739 static int SCI_Prepare(IXJ *j)
4740 {
4741 if (!SCI_Control(j, SCI_End))
4742 return 0;
4743
4744 if (!SCI_WaitLowSCI(j))
4745 return 0;
4746
4747 return 1;
4748 }
4749
4750 static int ixj_get_mixer(long val, IXJ *j)
4751 {
4752 int reg = (val & 0x1F00) >> 8;
4753 return j->mix.vol[reg];
4754 }
4755
4756 static int ixj_mixer(long val, IXJ *j)
4757 {
4758 BYTES bytes;
4759
4760 bytes.high = (val & 0x1F00) >> 8;
4761 bytes.low = val & 0x00FF;
4762
4763 /* save mixer value so we can get back later on */
4764 j->mix.vol[bytes.high] = bytes.low;
4765
4766 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4767
4768 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4769
4770 SCI_Control(j, SCI_Enable_Mixer);
4771
4772 SCI_Control(j, SCI_End);
4773
4774 return 0;
4775 }
4776
4777 static int daa_load(BYTES * p_bytes, IXJ *j)
4778 {
4779 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4780 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4781 if (!SCI_Control(j, SCI_Enable_DAA))
4782 return 0;
4783 else
4784 return 1;
4785 }
4786
4787 static int ixj_daa_cr4(IXJ *j, char reg)
4788 {
4789 BYTES bytes;
4790
4791 switch (j->daa_mode) {
4792 case SOP_PU_SLEEP:
4793 bytes.high = 0x14;
4794 break;
4795 case SOP_PU_RINGING:
4796 bytes.high = 0x54;
4797 break;
4798 case SOP_PU_CONVERSATION:
4799 bytes.high = 0x94;
4800 break;
4801 case SOP_PU_PULSEDIALING:
4802 bytes.high = 0xD4;
4803 break;
4804 }
4805
4806 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4807
4808 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4809 case 0:
4810 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4811 break;
4812 case 1:
4813 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4814 break;
4815 case 2:
4816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4817 break;
4818 case 3:
4819 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4820 break;
4821 }
4822
4823 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4824
4825 if (!daa_load(&bytes, j))
4826 return 0;
4827
4828 if (!SCI_Prepare(j))
4829 return 0;
4830
4831 return 1;
4832 }
4833
4834 static char daa_int_read(IXJ *j)
4835 {
4836 BYTES bytes;
4837
4838 if (!SCI_Prepare(j))
4839 return 0;
4840
4841 bytes.high = 0x38;
4842 bytes.low = 0x00;
4843 outb_p(bytes.high, j->XILINXbase + 0x03);
4844 outb_p(bytes.low, j->XILINXbase + 0x02);
4845
4846 if (!SCI_Control(j, SCI_Enable_DAA))
4847 return 0;
4848
4849 bytes.high = inb_p(j->XILINXbase + 0x03);
4850 bytes.low = inb_p(j->XILINXbase + 0x02);
4851 if (bytes.low != ALISDAA_ID_BYTE) {
4852 if (ixjdebug & 0x0001)
4853 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4854 return 0;
4855 }
4856 if (!SCI_Control(j, SCI_Enable_DAA))
4857 return 0;
4858 if (!SCI_Control(j, SCI_End))
4859 return 0;
4860
4861 bytes.high = inb_p(j->XILINXbase + 0x03);
4862 bytes.low = inb_p(j->XILINXbase + 0x02);
4863
4864 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4865
4866 return 1;
4867 }
4868
4869 static char daa_CR_read(IXJ *j, int cr)
4870 {
4871 IXJ_WORD wdata;
4872 BYTES bytes;
4873
4874 if (!SCI_Prepare(j))
4875 return 0;
4876
4877 switch (j->daa_mode) {
4878 case SOP_PU_SLEEP:
4879 bytes.high = 0x30 + cr;
4880 break;
4881 case SOP_PU_RINGING:
4882 bytes.high = 0x70 + cr;
4883 break;
4884 case SOP_PU_CONVERSATION:
4885 bytes.high = 0xB0 + cr;
4886 break;
4887 case SOP_PU_PULSEDIALING:
4888 bytes.high = 0xF0 + cr;
4889 break;
4890 }
4891
4892 bytes.low = 0x00;
4893
4894 outb_p(bytes.high, j->XILINXbase + 0x03);
4895 outb_p(bytes.low, j->XILINXbase + 0x02);
4896
4897 if (!SCI_Control(j, SCI_Enable_DAA))
4898 return 0;
4899
4900 bytes.high = inb_p(j->XILINXbase + 0x03);
4901 bytes.low = inb_p(j->XILINXbase + 0x02);
4902 if (bytes.low != ALISDAA_ID_BYTE) {
4903 if (ixjdebug & 0x0001)
4904 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4905 return 0;
4906 }
4907 if (!SCI_Control(j, SCI_Enable_DAA))
4908 return 0;
4909 if (!SCI_Control(j, SCI_End))
4910 return 0;
4911
4912 wdata.word = inw_p(j->XILINXbase + 0x02);
4913
4914 switch(cr){
4915 case 5:
4916 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4917 break;
4918 case 4:
4919 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4920 break;
4921 case 3:
4922 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4923 break;
4924 case 2:
4925 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4926 break;
4927 case 1:
4928 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4929 break;
4930 case 0:
4931 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4932 break;
4933 default:
4934 return 0;
4935 }
4936 return 1;
4937 }
4938
4939 static int ixj_daa_cid_reset(IXJ *j)
4940 {
4941 int i;
4942 BYTES bytes;
4943
4944 if (ixjdebug & 0x0002)
4945 printk("DAA Clearing CID ram\n");
4946
4947 if (!SCI_Prepare(j))
4948 return 0;
4949
4950 bytes.high = 0x58;
4951 bytes.low = 0x00;
4952 outb_p(bytes.high, j->XILINXbase + 0x03);
4953 outb_p(bytes.low, j->XILINXbase + 0x02);
4954
4955 if (!SCI_Control(j, SCI_Enable_DAA))
4956 return 0;
4957
4958 if (!SCI_WaitHighSCI(j))
4959 return 0;
4960
4961 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4962 bytes.high = bytes.low = 0x00;
4963 outb_p(bytes.high, j->XILINXbase + 0x03);
4964
4965 if (i < ALISDAA_CALLERID_SIZE - 1)
4966 outb_p(bytes.low, j->XILINXbase + 0x02);
4967
4968 if (!SCI_Control(j, SCI_Enable_DAA))
4969 return 0;
4970
4971 if (!SCI_WaitHighSCI(j))
4972 return 0;
4973
4974 }
4975
4976 if (!SCI_Control(j, SCI_End))
4977 return 0;
4978
4979 if (ixjdebug & 0x0002)
4980 printk("DAA CID ram cleared\n");
4981
4982 return 1;
4983 }
4984
4985 static int ixj_daa_cid_read(IXJ *j)
4986 {
4987 int i;
4988 BYTES bytes;
4989 char CID[ALISDAA_CALLERID_SIZE], mContinue;
4990 char *pIn, *pOut;
4991
4992 if (!SCI_Prepare(j))
4993 return 0;
4994
4995 bytes.high = 0x78;
4996 bytes.low = 0x00;
4997 outb_p(bytes.high, j->XILINXbase + 0x03);
4998 outb_p(bytes.low, j->XILINXbase + 0x02);
4999
5000 if (!SCI_Control(j, SCI_Enable_DAA))
5001 return 0;
5002
5003 if (!SCI_WaitHighSCI(j))
5004 return 0;
5005
5006 bytes.high = inb_p(j->XILINXbase + 0x03);
5007 bytes.low = inb_p(j->XILINXbase + 0x02);
5008 if (bytes.low != ALISDAA_ID_BYTE) {
5009 if (ixjdebug & 0x0001)
5010 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5011 return 0;
5012 }
5013 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5014 bytes.high = bytes.low = 0x00;
5015 outb_p(bytes.high, j->XILINXbase + 0x03);
5016 outb_p(bytes.low, j->XILINXbase + 0x02);
5017
5018 if (!SCI_Control(j, SCI_Enable_DAA))
5019 return 0;
5020
5021 if (!SCI_WaitHighSCI(j))
5022 return 0;
5023
5024 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5025 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5026 }
5027
5028 if (!SCI_Control(j, SCI_End))
5029 return 0;
5030
5031 pIn = CID;
5032 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5033 mContinue = 1;
5034 while (mContinue) {
5035 if ((pIn[1] & 0x03) == 0x01) {
5036 pOut[0] = pIn[0];
5037 }
5038 if ((pIn[2] & 0x0c) == 0x04) {
5039 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5040 }
5041 if ((pIn[3] & 0x30) == 0x10) {
5042 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5043 }
5044 if ((pIn[4] & 0xc0) == 0x40) {
5045 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5046 } else {
5047 mContinue = FALSE;
5048 }
5049 pIn += 5, pOut += 4;
5050 }
5051 memset(&j->cid, 0, sizeof(PHONE_CID));
5052 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5053 pOut += 4;
5054 strncpy(j->cid.month, pOut, 2);
5055 pOut += 2;
5056 strncpy(j->cid.day, pOut, 2);
5057 pOut += 2;
5058 strncpy(j->cid.hour, pOut, 2);
5059 pOut += 2;
5060 strncpy(j->cid.min, pOut, 2);
5061 pOut += 3;
5062 j->cid.numlen = *pOut;
5063 pOut += 1;
5064 strncpy(j->cid.number, pOut, j->cid.numlen);
5065 pOut += j->cid.numlen + 1;
5066 j->cid.namelen = *pOut;
5067 pOut += 1;
5068 strncpy(j->cid.name, pOut, j->cid.namelen);
5069
5070 ixj_daa_cid_reset(j);
5071 return 1;
5072 }
5073
5074 static char daa_get_version(IXJ *j)
5075 {
5076 BYTES bytes;
5077
5078 if (!SCI_Prepare(j))
5079 return 0;
5080
5081 bytes.high = 0x35;
5082 bytes.low = 0x00;
5083 outb_p(bytes.high, j->XILINXbase + 0x03);
5084 outb_p(bytes.low, j->XILINXbase + 0x02);
5085
5086 if (!SCI_Control(j, SCI_Enable_DAA))
5087 return 0;
5088
5089 bytes.high = inb_p(j->XILINXbase + 0x03);
5090 bytes.low = inb_p(j->XILINXbase + 0x02);
5091 if (bytes.low != ALISDAA_ID_BYTE) {
5092 if (ixjdebug & 0x0001)
5093 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5094 return 0;
5095 }
5096 if (!SCI_Control(j, SCI_Enable_DAA))
5097 return 0;
5098
5099 if (!SCI_Control(j, SCI_End))
5100 return 0;
5101
5102 bytes.high = inb_p(j->XILINXbase + 0x03);
5103 bytes.low = inb_p(j->XILINXbase + 0x02);
5104 if (ixjdebug & 0x0002)
5105 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5106 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5107 return bytes.high;
5108 }
5109
5110 static int daa_set_mode(IXJ *j, int mode)
5111 {
5112 /* NOTE:
5113 The DAA *MUST* be in the conversation mode if the
5114 PSTN line is to be seized (PSTN line off-hook).
5115 Taking the PSTN line off-hook while the DAA is in
5116 a mode other than conversation mode will cause a
5117 hardware failure of the ALIS-A part.
5118
5119 NOTE:
5120 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5121 if the PSTN line is on-hook. Failure to have the PSTN line
5122 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5123 ALIS-A part.
5124 */
5125
5126 BYTES bytes;
5127
5128 j->flags.pstn_rmr = 0;
5129
5130 if (!SCI_Prepare(j))
5131 return 0;
5132
5133 switch (mode) {
5134 case SOP_PU_RESET:
5135 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5136
5137 outb_p(j->pld_scrw.byte, j->XILINXbase);
5138 j->pld_slicw.bits.rly2 = 0;
5139 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5140 bytes.high = 0x10;
5141 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5142 daa_load(&bytes, j);
5143 if (!SCI_Prepare(j))
5144 return 0;
5145
5146 j->daa_mode = SOP_PU_SLEEP;
5147 break;
5148 case SOP_PU_SLEEP:
5149 if(j->daa_mode == SOP_PU_SLEEP)
5150 {
5151 break;
5152 }
5153 if (ixjdebug & 0x0008)
5154 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5155 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
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->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5169
5170 outb_p(j->pld_scrw.byte, j->XILINXbase);
5171 j->pld_slicw.bits.rly2 = 0;
5172 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5173 bytes.high = 0x10;
5174 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5175 daa_load(&bytes, j);
5176 if (!SCI_Prepare(j))
5177 return 0;
5178
5179 j->daa_mode = SOP_PU_SLEEP;
5180 j->flags.pstn_ringing = 0;
5181 j->ex.bits.pstn_ring = 0;
5182 j->pstn_sleeptil = jiffies + (hertz / 4);
5183 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5184 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5185 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5186 break;
5187 case SOP_PU_RINGING:
5188 if (ixjdebug & 0x0008)
5189 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5190 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5191
5192 outb_p(j->pld_scrw.byte, j->XILINXbase);
5193 j->pld_slicw.bits.rly2 = 0;
5194 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5195 bytes.high = 0x50;
5196 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5197 daa_load(&bytes, j);
5198 if (!SCI_Prepare(j))
5199 return 0;
5200 j->daa_mode = SOP_PU_RINGING;
5201 break;
5202 case SOP_PU_CONVERSATION:
5203 if (ixjdebug & 0x0008)
5204 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5205 bytes.high = 0x90;
5206 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5207 daa_load(&bytes, j);
5208 if (!SCI_Prepare(j))
5209 return 0;
5210 j->pld_slicw.bits.rly2 = 1;
5211 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5212 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5213
5214 outb_p(j->pld_scrw.byte, j->XILINXbase);
5215 j->daa_mode = SOP_PU_CONVERSATION;
5216 j->flags.pstn_ringing = 0;
5217 j->ex.bits.pstn_ring = 0;
5218 j->pstn_sleeptil = jiffies;
5219 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5220 break;
5221 case SOP_PU_PULSEDIALING:
5222 if (ixjdebug & 0x0008)
5223 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5224 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5225
5226 outb_p(j->pld_scrw.byte, j->XILINXbase);
5227 j->pld_slicw.bits.rly2 = 0;
5228 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5229 bytes.high = 0xD0;
5230 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5231 daa_load(&bytes, j);
5232 if (!SCI_Prepare(j))
5233 return 0;
5234 j->daa_mode = SOP_PU_PULSEDIALING;
5235 break;
5236 default:
5237 break;
5238 }
5239 return 1;
5240 }
5241
5242 static int ixj_daa_write(IXJ *j)
5243 {
5244 BYTES bytes;
5245
5246 j->flags.pstncheck = 1;
5247
5248 daa_set_mode(j, SOP_PU_SLEEP);
5249
5250 if (!SCI_Prepare(j))
5251 return 0;
5252
5253 outb_p(j->pld_scrw.byte, j->XILINXbase);
5254
5255 bytes.high = 0x14;
5256 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5257 if (!daa_load(&bytes, j))
5258 return 0;
5259
5260 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5261 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5262 if (!daa_load(&bytes, j))
5263 return 0;
5264
5265 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5266 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5267 if (!daa_load(&bytes, j))
5268 return 0;
5269
5270 if (!SCI_Prepare(j))
5271 return 0;
5272
5273 bytes.high = 0x1F;
5274 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5275 if (!daa_load(&bytes, j))
5276 return 0;
5277
5278 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5279 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5280 if (!daa_load(&bytes, j))
5281 return 0;
5282
5283 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5284 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5285 if (!daa_load(&bytes, j))
5286 return 0;
5287
5288 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5289 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5290 if (!daa_load(&bytes, j))
5291 return 0;
5292
5293 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5294 bytes.low = 0x00;
5295 if (!daa_load(&bytes, j))
5296 return 0;
5297
5298 if (!SCI_Prepare(j))
5299 return 0;
5300
5301 bytes.high = 0x00;
5302 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5303 if (!daa_load(&bytes, j))
5304 return 0;
5305
5306 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5307 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5308 if (!daa_load(&bytes, j))
5309 return 0;
5310
5311 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5312 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5313 if (!daa_load(&bytes, j))
5314 return 0;
5315
5316 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5317 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5318 if (!daa_load(&bytes, j))
5319 return 0;
5320
5321 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5322 bytes.low = 0x00;
5323 if (!daa_load(&bytes, j))
5324 return 0;
5325
5326 if (!SCI_Control(j, SCI_End))
5327 return 0;
5328 if (!SCI_WaitLowSCI(j))
5329 return 0;
5330
5331 bytes.high = 0x01;
5332 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5333 if (!daa_load(&bytes, j))
5334 return 0;
5335
5336 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5337 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5338 if (!daa_load(&bytes, j))
5339 return 0;
5340
5341 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5342 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5343 if (!daa_load(&bytes, j))
5344 return 0;
5345
5346 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5347 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5348 if (!daa_load(&bytes, j))
5349 return 0;
5350
5351 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5352 bytes.low = 0x00;
5353 if (!daa_load(&bytes, j))
5354 return 0;
5355
5356 if (!SCI_Control(j, SCI_End))
5357 return 0;
5358 if (!SCI_WaitLowSCI(j))
5359 return 0;
5360
5361 bytes.high = 0x02;
5362 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5363 if (!daa_load(&bytes, j))
5364 return 0;
5365
5366 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5367 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5368 if (!daa_load(&bytes, j))
5369 return 0;
5370
5371 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5372 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5373 if (!daa_load(&bytes, j))
5374 return 0;
5375
5376 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5377 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5378 if (!daa_load(&bytes, j))
5379 return 0;
5380
5381 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5382 bytes.low = 0x00;
5383 if (!daa_load(&bytes, j))
5384 return 0;
5385
5386 if (!SCI_Control(j, SCI_End))
5387 return 0;
5388 if (!SCI_WaitLowSCI(j))
5389 return 0;
5390
5391 bytes.high = 0x03;
5392 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5393 if (!daa_load(&bytes, j))
5394 return 0;
5395
5396 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5397 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5398 if (!daa_load(&bytes, j))
5399 return 0;
5400
5401 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5402 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5403 if (!daa_load(&bytes, j))
5404 return 0;
5405
5406 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5407 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5408 if (!daa_load(&bytes, j))
5409 return 0;
5410
5411 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5412 bytes.low = 0x00;
5413 if (!daa_load(&bytes, j))
5414 return 0;
5415
5416 if (!SCI_Control(j, SCI_End))
5417 return 0;
5418 if (!SCI_WaitLowSCI(j))
5419 return 0;
5420
5421 bytes.high = 0x04;
5422 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5423 if (!daa_load(&bytes, j))
5424 return 0;
5425
5426 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5427 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5428 if (!daa_load(&bytes, j))
5429 return 0;
5430
5431 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5432 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5433 if (!daa_load(&bytes, j))
5434 return 0;
5435
5436 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5437 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5438 if (!daa_load(&bytes, j))
5439 return 0;
5440
5441 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5442 bytes.low = 0x00;
5443 if (!daa_load(&bytes, j))
5444 return 0;
5445
5446 if (!SCI_Control(j, SCI_End))
5447 return 0;
5448 if (!SCI_WaitLowSCI(j))
5449 return 0;
5450
5451 bytes.high = 0x05;
5452 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5453 if (!daa_load(&bytes, j))
5454 return 0;
5455
5456 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5457 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5458 if (!daa_load(&bytes, j))
5459 return 0;
5460
5461 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5462 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5463 if (!daa_load(&bytes, j))
5464 return 0;
5465
5466 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5467 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5468 if (!daa_load(&bytes, j))
5469 return 0;
5470
5471 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5472 bytes.low = 0x00;
5473 if (!daa_load(&bytes, j))
5474 return 0;
5475
5476 if (!SCI_Control(j, SCI_End))
5477 return 0;
5478 if (!SCI_WaitLowSCI(j))
5479 return 0;
5480
5481 bytes.high = 0x06;
5482 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5483 if (!daa_load(&bytes, j))
5484 return 0;
5485
5486 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5487 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5488 if (!daa_load(&bytes, j))
5489 return 0;
5490
5491 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5492 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5493 if (!daa_load(&bytes, j))
5494 return 0;
5495
5496 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5497 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5498 if (!daa_load(&bytes, j))
5499 return 0;
5500
5501 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5502 bytes.low = 0x00;
5503 if (!daa_load(&bytes, j))
5504 return 0;
5505
5506 if (!SCI_Control(j, SCI_End))
5507 return 0;
5508 if (!SCI_WaitLowSCI(j))
5509 return 0;
5510
5511 bytes.high = 0x07;
5512 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5513 if (!daa_load(&bytes, j))
5514 return 0;
5515
5516 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5517 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5518 if (!daa_load(&bytes, j))
5519 return 0;
5520
5521 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5522 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5523 if (!daa_load(&bytes, j))
5524 return 0;
5525
5526 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5527 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5528 if (!daa_load(&bytes, j))
5529 return 0;
5530
5531 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5532 bytes.low = 0x00;
5533 if (!daa_load(&bytes, j))
5534 return 0;
5535
5536 if (!SCI_Control(j, SCI_End))
5537 return 0;
5538 if (!SCI_WaitLowSCI(j))
5539 return 0;
5540
5541 bytes.high = 0x08;
5542 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5543 if (!daa_load(&bytes, j))
5544 return 0;
5545
5546 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5547 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5548 if (!daa_load(&bytes, j))
5549 return 0;
5550
5551 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5552 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5553 if (!daa_load(&bytes, j))
5554 return 0;
5555
5556 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5557 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5558 if (!daa_load(&bytes, j))
5559 return 0;
5560
5561 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5562 bytes.low = 0x00;
5563 if (!daa_load(&bytes, j))
5564 return 0;
5565
5566 if (!SCI_Control(j, SCI_End))
5567 return 0;
5568 if (!SCI_WaitLowSCI(j))
5569 return 0;
5570
5571 bytes.high = 0x09;
5572 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5573 if (!daa_load(&bytes, j))
5574 return 0;
5575
5576 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5577 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5578 if (!daa_load(&bytes, j))
5579 return 0;
5580
5581 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5582 bytes.low = 0x00;
5583 if (!daa_load(&bytes, j))
5584 return 0;
5585
5586 if (!SCI_Control(j, SCI_End))
5587 return 0;
5588 if (!SCI_WaitLowSCI(j))
5589 return 0;
5590
5591 bytes.high = 0x0A;
5592 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5593 if (!daa_load(&bytes, j))
5594 return 0;
5595
5596 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5597 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5598 if (!daa_load(&bytes, j))
5599 return 0;
5600
5601 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5602 bytes.low = 0x00;
5603 if (!daa_load(&bytes, j))
5604 return 0;
5605
5606 if (!SCI_Control(j, SCI_End))
5607 return 0;
5608 if (!SCI_WaitLowSCI(j))
5609 return 0;
5610
5611 bytes.high = 0x0B;
5612 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5613 if (!daa_load(&bytes, j))
5614 return 0;
5615
5616 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5617 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5618 if (!daa_load(&bytes, j))
5619 return 0;
5620
5621 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5622 bytes.low = 0x00;
5623 if (!daa_load(&bytes, j))
5624 return 0;
5625
5626 if (!SCI_Control(j, SCI_End))
5627 return 0;
5628 if (!SCI_WaitLowSCI(j))
5629 return 0;
5630
5631 bytes.high = 0x0C;
5632 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5633 if (!daa_load(&bytes, j))
5634 return 0;
5635
5636 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5637 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5638 if (!daa_load(&bytes, j))
5639 return 0;
5640
5641 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5642 bytes.low = 0x00;
5643 if (!daa_load(&bytes, j))
5644 return 0;
5645
5646 if (!SCI_Control(j, SCI_End))
5647 return 0;
5648 if (!SCI_WaitLowSCI(j))
5649 return 0;
5650
5651 bytes.high = 0x0D;
5652 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5653 if (!daa_load(&bytes, j))
5654 return 0;
5655
5656 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5657 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5658 if (!daa_load(&bytes, j))
5659 return 0;
5660
5661 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5662 bytes.low = 0x00;
5663 if (!daa_load(&bytes, j))
5664 return 0;
5665
5666 if (!SCI_Control(j, SCI_End))
5667 return 0;
5668 if (!SCI_WaitLowSCI(j))
5669 return 0;
5670
5671 bytes.high = 0x0E;
5672 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5673 if (!daa_load(&bytes, j))
5674 return 0;
5675
5676 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5677 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5678 if (!daa_load(&bytes, j))
5679 return 0;
5680
5681 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5682 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5683 if (!daa_load(&bytes, j))
5684 return 0;
5685
5686 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5687 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5688 if (!daa_load(&bytes, j))
5689 return 0;
5690
5691 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5692 bytes.low = 0x00;
5693 if (!daa_load(&bytes, j))
5694 return 0;
5695
5696 if (!SCI_Control(j, SCI_End))
5697 return 0;
5698 if (!SCI_WaitLowSCI(j))
5699 return 0;
5700
5701 bytes.high = 0x0F;
5702 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5703 if (!daa_load(&bytes, j))
5704 return 0;
5705
5706 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5707 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5708 if (!daa_load(&bytes, j))
5709 return 0;
5710
5711 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5712 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5713 if (!daa_load(&bytes, j))
5714 return 0;
5715
5716 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5717 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5718 if (!daa_load(&bytes, j))
5719 return 0;
5720
5721 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5722 bytes.low = 0x00;
5723 if (!daa_load(&bytes, j))
5724 return 0;
5725
5726 udelay(32);
5727 j->pld_scrr.byte = inb_p(j->XILINXbase);
5728 if (!SCI_Control(j, SCI_End))
5729 return 0;
5730
5731 outb_p(j->pld_scrw.byte, j->XILINXbase);
5732
5733 if (ixjdebug & 0x0002)
5734 printk("DAA Coefficients Loaded\n");
5735
5736 j->flags.pstncheck = 0;
5737 return 1;
5738 }
5739
5740 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5741 {
5742 j->tone_off_time = arg;
5743 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5744
5745 return -1;
5746 if (ixj_WriteDSPCommand(arg, j))
5747 return -1;
5748 return 0;
5749 }
5750
5751 static int ixj_get_tone_on(IXJ *j)
5752 {
5753 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5754
5755 return -1;
5756 return 0;
5757 }
5758
5759 static int ixj_get_tone_off(IXJ *j)
5760 {
5761 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5762
5763 return -1;
5764 return 0;
5765 }
5766
5767 static void ixj_busytone(IXJ *j)
5768 {
5769 j->flags.ringback = 0;
5770 j->flags.dialtone = 0;
5771 j->flags.busytone = 1;
5772 ixj_set_tone_on(0x07D0, j);
5773 ixj_set_tone_off(0x07D0, j);
5774 ixj_play_tone(j, 27);
5775 }
5776
5777 static void ixj_dialtone(IXJ *j)
5778 {
5779 j->flags.ringback = 0;
5780 j->flags.dialtone = 1;
5781 j->flags.busytone = 0;
5782 if (j->dsp.low == 0x20) {
5783 return;
5784 } else {
5785 ixj_set_tone_on(0xFFFF, j);
5786 ixj_set_tone_off(0x0000, j);
5787 ixj_play_tone(j, 25);
5788 }
5789 }
5790
5791 static void ixj_cpt_stop(IXJ *j)
5792 {
5793 if(j->tone_state || j->tone_cadence_state)
5794 {
5795 j->flags.dialtone = 0;
5796 j->flags.busytone = 0;
5797 j->flags.ringback = 0;
5798 ixj_set_tone_on(0x0001, j);
5799 ixj_set_tone_off(0x0000, j);
5800 ixj_play_tone(j, 0);
5801 j->tone_state = j->tone_cadence_state = 0;
5802 if (j->cadence_t) {
5803 kfree(j->cadence_t->ce);
5804 kfree(j->cadence_t);
5805 j->cadence_t = NULL;
5806 }
5807 }
5808 if (j->play_mode == -1 && j->rec_mode == -1)
5809 idle(j);
5810 if (j->play_mode != -1 && j->dsp.low == 0x20)
5811 ixj_play_start(j);
5812 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5813 ixj_record_start(j);
5814 }
5815
5816 static void ixj_ringback(IXJ *j)
5817 {
5818 j->flags.busytone = 0;
5819 j->flags.dialtone = 0;
5820 j->flags.ringback = 1;
5821 ixj_set_tone_on(0x0FA0, j);
5822 ixj_set_tone_off(0x2EE0, j);
5823 ixj_play_tone(j, 26);
5824 }
5825
5826 static void ixj_testram(IXJ *j)
5827 {
5828 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5829 }
5830
5831 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5832 {
5833 ixj_cadence *lcp;
5834 IXJ_CADENCE_ELEMENT __user *cep;
5835 IXJ_CADENCE_ELEMENT *lcep;
5836 IXJ_TONE ti;
5837 int err;
5838
5839 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5840 if (lcp == NULL)
5841 return -ENOMEM;
5842
5843 err = -EFAULT;
5844 if (copy_from_user(&lcp->elements_used,
5845 &cp->elements_used, sizeof(int)))
5846 goto out;
5847 if (copy_from_user(&lcp->termination,
5848 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5849 goto out;
5850 if (get_user(cep, &cp->ce))
5851 goto out;
5852
5853 err = -EINVAL;
5854 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5855 goto out;
5856
5857 err = -ENOMEM;
5858 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5859 if (!lcep)
5860 goto out;
5861
5862 err = -EFAULT;
5863 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5864 goto out1;
5865
5866 if (j->cadence_t) {
5867 kfree(j->cadence_t->ce);
5868 kfree(j->cadence_t);
5869 }
5870 lcp->ce = (void *) lcep;
5871 j->cadence_t = lcp;
5872 j->tone_cadence_state = 0;
5873 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5874 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5875 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5876 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5877 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5878 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5879 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5880 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5881 ixj_init_tone(j, &ti);
5882 }
5883 ixj_play_tone(j, lcp->ce[0].index);
5884 return 1;
5885 out1:
5886 kfree(lcep);
5887 out:
5888 kfree(lcp);
5889 return err;
5890 }
5891
5892 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5893 {
5894 IXJ_FILTER_CADENCE *lcp;
5895 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5896 if (lcp == NULL) {
5897 if(ixjdebug & 0x0001) {
5898 printk(KERN_INFO "Could not allocate memory for cadence\n");
5899 }
5900 return -ENOMEM;
5901 }
5902 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5903 if(ixjdebug & 0x0001) {
5904 printk(KERN_INFO "Could not copy cadence to kernel\n");
5905 }
5906 kfree(lcp);
5907 return -EFAULT;
5908 }
5909 if (lcp->filter > 5) {
5910 if(ixjdebug & 0x0001) {
5911 printk(KERN_INFO "Cadence out of range\n");
5912 }
5913 kfree(lcp);
5914 return -1;
5915 }
5916 j->cadence_f[lcp->filter].state = 0;
5917 j->cadence_f[lcp->filter].enable = lcp->enable;
5918 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5919 j->cadence_f[lcp->filter].on1 = lcp->on1;
5920 j->cadence_f[lcp->filter].on1min = 0;
5921 j->cadence_f[lcp->filter].on1max = 0;
5922 j->cadence_f[lcp->filter].off1 = lcp->off1;
5923 j->cadence_f[lcp->filter].off1min = 0;
5924 j->cadence_f[lcp->filter].off1max = 0;
5925 j->cadence_f[lcp->filter].on2 = lcp->on2;
5926 j->cadence_f[lcp->filter].on2min = 0;
5927 j->cadence_f[lcp->filter].on2max = 0;
5928 j->cadence_f[lcp->filter].off2 = lcp->off2;
5929 j->cadence_f[lcp->filter].off2min = 0;
5930 j->cadence_f[lcp->filter].off2max = 0;
5931 j->cadence_f[lcp->filter].on3 = lcp->on3;
5932 j->cadence_f[lcp->filter].on3min = 0;
5933 j->cadence_f[lcp->filter].on3max = 0;
5934 j->cadence_f[lcp->filter].off3 = lcp->off3;
5935 j->cadence_f[lcp->filter].off3min = 0;
5936 j->cadence_f[lcp->filter].off3max = 0;
5937 if(ixjdebug & 0x0002) {
5938 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5939 }
5940 kfree(lcp);
5941 return 0;
5942 }
5943
5944 static void add_caps(IXJ *j)
5945 {
5946 j->caps = 0;
5947 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5948 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5949 j->caplist[j->caps].captype = vendor;
5950 j->caplist[j->caps].handle = j->caps++;
5951 j->caplist[j->caps].captype = device;
5952 switch (j->cardtype) {
5953 case QTI_PHONEJACK:
5954 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5955 break;
5956 case QTI_LINEJACK:
5957 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5958 break;
5959 case QTI_PHONEJACK_LITE:
5960 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5961 break;
5962 case QTI_PHONEJACK_PCI:
5963 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5964 break;
5965 case QTI_PHONECARD:
5966 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5967 break;
5968 }
5969 j->caplist[j->caps].cap = j->cardtype;
5970 j->caplist[j->caps].handle = j->caps++;
5971 strcpy(j->caplist[j->caps].desc, "POTS");
5972 j->caplist[j->caps].captype = port;
5973 j->caplist[j->caps].cap = pots;
5974 j->caplist[j->caps].handle = j->caps++;
5975
5976 /* add devices that can do speaker/mic */
5977 switch (j->cardtype) {
5978 case QTI_PHONEJACK:
5979 case QTI_LINEJACK:
5980 case QTI_PHONEJACK_PCI:
5981 case QTI_PHONECARD:
5982 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5983 j->caplist[j->caps].captype = port;
5984 j->caplist[j->caps].cap = speaker;
5985 j->caplist[j->caps].handle = j->caps++;
5986 default:
5987 break;
5988 }
5989
5990 /* add devices that can do handset */
5991 switch (j->cardtype) {
5992 case QTI_PHONEJACK:
5993 strcpy(j->caplist[j->caps].desc, "HANDSET");
5994 j->caplist[j->caps].captype = port;
5995 j->caplist[j->caps].cap = handset;
5996 j->caplist[j->caps].handle = j->caps++;
5997 break;
5998 default:
5999 break;
6000 }
6001
6002 /* add devices that can do PSTN */
6003 switch (j->cardtype) {
6004 case QTI_LINEJACK:
6005 strcpy(j->caplist[j->caps].desc, "PSTN");
6006 j->caplist[j->caps].captype = port;
6007 j->caplist[j->caps].cap = pstn;
6008 j->caplist[j->caps].handle = j->caps++;
6009 break;
6010 default:
6011 break;
6012 }
6013
6014 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6015 strcpy(j->caplist[j->caps].desc, "ULAW");
6016 j->caplist[j->caps].captype = codec;
6017 j->caplist[j->caps].cap = ULAW;
6018 j->caplist[j->caps].handle = j->caps++;
6019
6020 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6021 j->caplist[j->caps].captype = codec;
6022 j->caplist[j->caps].cap = LINEAR16;
6023 j->caplist[j->caps].handle = j->caps++;
6024
6025 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6026 j->caplist[j->caps].captype = codec;
6027 j->caplist[j->caps].cap = LINEAR8;
6028 j->caplist[j->caps].handle = j->caps++;
6029
6030 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6031 j->caplist[j->caps].captype = codec;
6032 j->caplist[j->caps].cap = WSS;
6033 j->caplist[j->caps].handle = j->caps++;
6034
6035 /* software ALAW codec, made from ULAW */
6036 strcpy(j->caplist[j->caps].desc, "ALAW");
6037 j->caplist[j->caps].captype = codec;
6038 j->caplist[j->caps].cap = ALAW;
6039 j->caplist[j->caps].handle = j->caps++;
6040
6041 /* version 12 of the 8020 does the following codecs in a broken way */
6042 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6043 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6044 j->caplist[j->caps].captype = codec;
6045 j->caplist[j->caps].cap = G723_63;
6046 j->caplist[j->caps].handle = j->caps++;
6047
6048 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6049 j->caplist[j->caps].captype = codec;
6050 j->caplist[j->caps].cap = G723_53;
6051 j->caplist[j->caps].handle = j->caps++;
6052
6053 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6054 j->caplist[j->caps].captype = codec;
6055 j->caplist[j->caps].cap = TS48;
6056 j->caplist[j->caps].handle = j->caps++;
6057
6058 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6059 j->caplist[j->caps].captype = codec;
6060 j->caplist[j->caps].cap = TS41;
6061 j->caplist[j->caps].handle = j->caps++;
6062 }
6063
6064 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6065 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6066 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6067 j->caplist[j->caps].captype = codec;
6068 j->caplist[j->caps].cap = TS85;
6069 j->caplist[j->caps].handle = j->caps++;
6070 }
6071
6072 /* 8021 chips can do G728 */
6073 if (j->dsp.low == 0x21) {
6074 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6075 j->caplist[j->caps].captype = codec;
6076 j->caplist[j->caps].cap = G728;
6077 j->caplist[j->caps].handle = j->caps++;
6078 }
6079
6080 /* 8021/8022 chips can do G729 if loaded */
6081 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6082 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6083 j->caplist[j->caps].captype = codec;
6084 j->caplist[j->caps].cap = G729;
6085 j->caplist[j->caps].handle = j->caps++;
6086 }
6087 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6088 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6089 j->caplist[j->caps].captype = codec;
6090 j->caplist[j->caps].cap = G729B;
6091 j->caplist[j->caps].handle = j->caps++;
6092 }
6093 }
6094
6095 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6096 {
6097 int cnt;
6098 int retval = 0;
6099 for (cnt = 0; cnt < j->caps; cnt++) {
6100 if (pcreq->captype == j->caplist[cnt].captype
6101 && pcreq->cap == j->caplist[cnt].cap) {
6102 retval = 1;
6103 break;
6104 }
6105 }
6106 return retval;
6107 }
6108
6109 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6110 {
6111 IXJ_TONE ti;
6112 IXJ_FILTER jf;
6113 IXJ_FILTER_RAW jfr;
6114 void __user *argp = (void __user *)arg;
6115
6116 unsigned int raise, mant;
6117 unsigned int minor = iminor(inode);
6118 int board = NUM(inode);
6119
6120 IXJ *j = get_ixj(NUM(inode));
6121
6122 int retval = 0;
6123
6124 /*
6125 * Set up locks to ensure that only one process is talking to the DSP at a time.
6126 * This is necessary to keep the DSP from locking up.
6127 */
6128 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6129 set_current_state(TASK_INTERRUPTIBLE);
6130 schedule_timeout(1);
6131 }
6132 if (ixjdebug & 0x0040)
6133 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6134 if (minor >= IXJMAX) {
6135 clear_bit(board, &j->busyflags);
6136 return -ENODEV;
6137 }
6138 /*
6139 * Check ioctls only root can use.
6140 */
6141 if (!capable(CAP_SYS_ADMIN)) {
6142 switch (cmd) {
6143 case IXJCTL_TESTRAM:
6144 case IXJCTL_HZ:
6145 retval = -EPERM;
6146 }
6147 }
6148 switch (cmd) {
6149 case IXJCTL_TESTRAM:
6150 ixj_testram(j);
6151 retval = (j->ssr.high << 8) + j->ssr.low;
6152 break;
6153 case IXJCTL_CARDTYPE:
6154 retval = j->cardtype;
6155 break;
6156 case IXJCTL_SERIAL:
6157 retval = j->serial;
6158 break;
6159 case IXJCTL_VERSION:
6160 {
6161 char arg_str[100];
6162 snprintf(arg_str, sizeof(arg_str),
6163 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6164 IXJ_VER_MINOR, IXJ_BLD_VER);
6165 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6166 retval = -EFAULT;
6167 }
6168 break;
6169 case PHONE_RING_CADENCE:
6170 j->ring_cadence = arg;
6171 break;
6172 case IXJCTL_CIDCW:
6173 if(arg) {
6174 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175 retval = -EFAULT;
6176 break;
6177 }
6178 } else {
6179 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6180 }
6181 ixj_write_cidcw(j);
6182 break;
6183 /* Binary compatbility */
6184 case OLD_PHONE_RING_START:
6185 arg = 0;
6186 /* Fall through */
6187 case PHONE_RING_START:
6188 if(arg) {
6189 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6190 retval = -EFAULT;
6191 break;
6192 }
6193 ixj_write_cid(j);
6194 } else {
6195 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6196 }
6197 ixj_ring_start(j);
6198 break;
6199 case PHONE_RING_STOP:
6200 j->flags.cringing = 0;
6201 if(j->cadence_f[5].enable) {
6202 j->cadence_f[5].state = 0;
6203 }
6204 ixj_ring_off(j);
6205 break;
6206 case PHONE_RING:
6207 retval = ixj_ring(j);
6208 break;
6209 case PHONE_EXCEPTION:
6210 retval = j->ex.bytes;
6211 if(j->ex.bits.flash) {
6212 j->flash_end = 0;
6213 j->ex.bits.flash = 0;
6214 }
6215 j->ex.bits.pstn_ring = 0;
6216 j->ex.bits.caller_id = 0;
6217 j->ex.bits.pstn_wink = 0;
6218 j->ex.bits.f0 = 0;
6219 j->ex.bits.f1 = 0;
6220 j->ex.bits.f2 = 0;
6221 j->ex.bits.f3 = 0;
6222 j->ex.bits.fc0 = 0;
6223 j->ex.bits.fc1 = 0;
6224 j->ex.bits.fc2 = 0;
6225 j->ex.bits.fc3 = 0;
6226 j->ex.bits.reserved = 0;
6227 break;
6228 case PHONE_HOOKSTATE:
6229 j->ex.bits.hookstate = 0;
6230 retval = j->hookstate; //j->r_hook;
6231 break;
6232 case IXJCTL_SET_LED:
6233 LED_SetState(arg, j);
6234 break;
6235 case PHONE_FRAME:
6236 retval = set_base_frame(j, arg);
6237 break;
6238 case PHONE_REC_CODEC:
6239 retval = set_rec_codec(j, arg);
6240 break;
6241 case PHONE_VAD:
6242 ixj_vad(j, arg);
6243 break;
6244 case PHONE_REC_START:
6245 ixj_record_start(j);
6246 break;
6247 case PHONE_REC_STOP:
6248 ixj_record_stop(j);
6249 break;
6250 case PHONE_REC_DEPTH:
6251 set_rec_depth(j, arg);
6252 break;
6253 case PHONE_REC_VOLUME:
6254 if(arg == -1) {
6255 retval = get_rec_volume(j);
6256 }
6257 else {
6258 set_rec_volume(j, arg);
6259 retval = arg;
6260 }
6261 break;
6262 case PHONE_REC_VOLUME_LINEAR:
6263 if(arg == -1) {
6264 retval = get_rec_volume_linear(j);
6265 }
6266 else {
6267 set_rec_volume_linear(j, arg);
6268 retval = arg;
6269 }
6270 break;
6271 case IXJCTL_DTMF_PRESCALE:
6272 if(arg == -1) {
6273 retval = get_dtmf_prescale(j);
6274 }
6275 else {
6276 set_dtmf_prescale(j, arg);
6277 retval = arg;
6278 }
6279 break;
6280 case PHONE_REC_LEVEL:
6281 retval = get_rec_level(j);
6282 break;
6283 case IXJCTL_SC_RXG:
6284 retval = ixj_siadc(j, arg);
6285 break;
6286 case IXJCTL_SC_TXG:
6287 retval = ixj_sidac(j, arg);
6288 break;
6289 case IXJCTL_AEC_START:
6290 ixj_aec_start(j, arg);
6291 break;
6292 case IXJCTL_AEC_STOP:
6293 aec_stop(j);
6294 break;
6295 case IXJCTL_AEC_GET_LEVEL:
6296 retval = j->aec_level;
6297 break;
6298 case PHONE_PLAY_CODEC:
6299 retval = set_play_codec(j, arg);
6300 break;
6301 case PHONE_PLAY_START:
6302 retval = ixj_play_start(j);
6303 break;
6304 case PHONE_PLAY_STOP:
6305 ixj_play_stop(j);
6306 break;
6307 case PHONE_PLAY_DEPTH:
6308 set_play_depth(j, arg);
6309 break;
6310 case PHONE_PLAY_VOLUME:
6311 if(arg == -1) {
6312 retval = get_play_volume(j);
6313 }
6314 else {
6315 set_play_volume(j, arg);
6316 retval = arg;
6317 }
6318 break;
6319 case PHONE_PLAY_VOLUME_LINEAR:
6320 if(arg == -1) {
6321 retval = get_play_volume_linear(j);
6322 }
6323 else {
6324 set_play_volume_linear(j, arg);
6325 retval = arg;
6326 }
6327 break;
6328 case PHONE_PLAY_LEVEL:
6329 retval = get_play_level(j);
6330 break;
6331 case IXJCTL_DSP_TYPE:
6332 retval = (j->dsp.high << 8) + j->dsp.low;
6333 break;
6334 case IXJCTL_DSP_VERSION:
6335 retval = (j->ver.high << 8) + j->ver.low;
6336 break;
6337 case IXJCTL_HZ:
6338 hertz = arg;
6339 break;
6340 case IXJCTL_RATE:
6341 if (arg > hertz)
6342 retval = -1;
6343 else
6344 samplerate = arg;
6345 break;
6346 case IXJCTL_DRYBUFFER_READ:
6347 put_user(j->drybuffer, (unsigned long __user *) argp);
6348 break;
6349 case IXJCTL_DRYBUFFER_CLEAR:
6350 j->drybuffer = 0;
6351 break;
6352 case IXJCTL_FRAMES_READ:
6353 put_user(j->framesread, (unsigned long __user *) argp);
6354 break;
6355 case IXJCTL_FRAMES_WRITTEN:
6356 put_user(j->frameswritten, (unsigned long __user *) argp);
6357 break;
6358 case IXJCTL_READ_WAIT:
6359 put_user(j->read_wait, (unsigned long __user *) argp);
6360 break;
6361 case IXJCTL_WRITE_WAIT:
6362 put_user(j->write_wait, (unsigned long __user *) argp);
6363 break;
6364 case PHONE_MAXRINGS:
6365 j->maxrings = arg;
6366 break;
6367 case PHONE_SET_TONE_ON_TIME:
6368 ixj_set_tone_on(arg, j);
6369 break;
6370 case PHONE_SET_TONE_OFF_TIME:
6371 ixj_set_tone_off(arg, j);
6372 break;
6373 case PHONE_GET_TONE_ON_TIME:
6374 if (ixj_get_tone_on(j)) {
6375 retval = -1;
6376 } else {
6377 retval = (j->ssr.high << 8) + j->ssr.low;
6378 }
6379 break;
6380 case PHONE_GET_TONE_OFF_TIME:
6381 if (ixj_get_tone_off(j)) {
6382 retval = -1;
6383 } else {
6384 retval = (j->ssr.high << 8) + j->ssr.low;
6385 }
6386 break;
6387 case PHONE_PLAY_TONE:
6388 if (!j->tone_state)
6389 retval = ixj_play_tone(j, arg);
6390 else
6391 retval = -1;
6392 break;
6393 case PHONE_GET_TONE_STATE:
6394 retval = j->tone_state;
6395 break;
6396 case PHONE_DTMF_READY:
6397 retval = j->ex.bits.dtmf_ready;
6398 break;
6399 case PHONE_GET_DTMF:
6400 if (ixj_hookstate(j)) {
6401 if (j->dtmf_rp != j->dtmf_wp) {
6402 retval = j->dtmfbuffer[j->dtmf_rp];
6403 j->dtmf_rp++;
6404 if (j->dtmf_rp == 79)
6405 j->dtmf_rp = 0;
6406 if (j->dtmf_rp == j->dtmf_wp) {
6407 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6408 }
6409 }
6410 }
6411 break;
6412 case PHONE_GET_DTMF_ASCII:
6413 if (ixj_hookstate(j)) {
6414 if (j->dtmf_rp != j->dtmf_wp) {
6415 switch (j->dtmfbuffer[j->dtmf_rp]) {
6416 case 10:
6417 retval = 42; /* '*'; */
6418
6419 break;
6420 case 11:
6421 retval = 48; /*'0'; */
6422
6423 break;
6424 case 12:
6425 retval = 35; /*'#'; */
6426
6427 break;
6428 case 28:
6429 retval = 65; /*'A'; */
6430
6431 break;
6432 case 29:
6433 retval = 66; /*'B'; */
6434
6435 break;
6436 case 30:
6437 retval = 67; /*'C'; */
6438
6439 break;
6440 case 31:
6441 retval = 68; /*'D'; */
6442
6443 break;
6444 default:
6445 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6446 break;
6447 }
6448 j->dtmf_rp++;
6449 if (j->dtmf_rp == 79)
6450 j->dtmf_rp = 0;
6451 if(j->dtmf_rp == j->dtmf_wp)
6452 {
6453 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6454 }
6455 }
6456 }
6457 break;
6458 case PHONE_DTMF_OOB:
6459 j->flags.dtmf_oob = arg;
6460 break;
6461 case PHONE_DIALTONE:
6462 ixj_dialtone(j);
6463 break;
6464 case PHONE_BUSY:
6465 ixj_busytone(j);
6466 break;
6467 case PHONE_RINGBACK:
6468 ixj_ringback(j);
6469 break;
6470 case PHONE_WINK:
6471 if(j->cardtype == QTI_PHONEJACK)
6472 retval = -1;
6473 else
6474 retval = ixj_wink(j);
6475 break;
6476 case PHONE_CPT_STOP:
6477 ixj_cpt_stop(j);
6478 break;
6479 case PHONE_QUERY_CODEC:
6480 {
6481 struct phone_codec_data pd;
6482 int val;
6483 int proto_size[] = {
6484 -1,
6485 12, 10, 16, 9, 8, 48, 5,
6486 40, 40, 80, 40, 40, 6
6487 };
6488 if(copy_from_user(&pd, argp, sizeof(pd))) {
6489 retval = -EFAULT;
6490 break;
6491 }
6492 if(pd.type<1 || pd.type>13) {
6493 retval = -EPROTONOSUPPORT;
6494 break;
6495 }
6496 if(pd.type<G729)
6497 val=proto_size[pd.type];
6498 else switch(j->baseframe.low)
6499 {
6500 case 0xA0:val=2*proto_size[pd.type];break;
6501 case 0x50:val=proto_size[pd.type];break;
6502 default:val=proto_size[pd.type]*3;break;
6503 }
6504 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6505 if(copy_to_user(argp, &pd, sizeof(pd)))
6506 retval = -EFAULT;
6507 break;
6508 }
6509 case IXJCTL_DSP_IDLE:
6510 idle(j);
6511 break;
6512 case IXJCTL_MIXER:
6513 if ((arg & 0xff) == 0xff)
6514 retval = ixj_get_mixer(arg, j);
6515 else
6516 ixj_mixer(arg, j);
6517 break;
6518 case IXJCTL_DAA_COEFF_SET:
6519 switch (arg) {
6520 case DAA_US:
6521 DAA_Coeff_US(j);
6522 retval = ixj_daa_write(j);
6523 break;
6524 case DAA_UK:
6525 DAA_Coeff_UK(j);
6526 retval = ixj_daa_write(j);
6527 break;
6528 case DAA_FRANCE:
6529 DAA_Coeff_France(j);
6530 retval = ixj_daa_write(j);
6531 break;
6532 case DAA_GERMANY:
6533 DAA_Coeff_Germany(j);
6534 retval = ixj_daa_write(j);
6535 break;
6536 case DAA_AUSTRALIA:
6537 DAA_Coeff_Australia(j);
6538 retval = ixj_daa_write(j);
6539 break;
6540 case DAA_JAPAN:
6541 DAA_Coeff_Japan(j);
6542 retval = ixj_daa_write(j);
6543 break;
6544 default:
6545 retval = 1;
6546 break;
6547 }
6548 break;
6549 case IXJCTL_DAA_AGAIN:
6550 ixj_daa_cr4(j, arg | 0x02);
6551 break;
6552 case IXJCTL_PSTN_LINETEST:
6553 retval = ixj_linetest(j);
6554 break;
6555 case IXJCTL_VMWI:
6556 ixj_write_vmwi(j, arg);
6557 break;
6558 case IXJCTL_CID:
6559 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6560 retval = -EFAULT;
6561 j->ex.bits.caller_id = 0;
6562 break;
6563 case IXJCTL_WINK_DURATION:
6564 j->winktime = arg;
6565 break;
6566 case IXJCTL_PORT:
6567 if (arg)
6568 retval = ixj_set_port(j, arg);
6569 else
6570 retval = j->port;
6571 break;
6572 case IXJCTL_POTS_PSTN:
6573 retval = ixj_set_pots(j, arg);
6574 break;
6575 case PHONE_CAPABILITIES:
6576 add_caps(j);
6577 retval = j->caps;
6578 break;
6579 case PHONE_CAPABILITIES_LIST:
6580 add_caps(j);
6581 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6582 retval = -EFAULT;
6583 break;
6584 case PHONE_CAPABILITIES_CHECK:
6585 {
6586 struct phone_capability cap;
6587 if (copy_from_user(&cap, argp, sizeof(cap)))
6588 retval = -EFAULT;
6589 else {
6590 add_caps(j);
6591 retval = capabilities_check(j, &cap);
6592 }
6593 }
6594 break;
6595 case PHONE_PSTN_SET_STATE:
6596 daa_set_mode(j, arg);
6597 break;
6598 case PHONE_PSTN_GET_STATE:
6599 retval = j->daa_mode;
6600 j->ex.bits.pstn_ring = 0;
6601 break;
6602 case IXJCTL_SET_FILTER:
6603 if (copy_from_user(&jf, argp, sizeof(jf)))
6604 retval = -EFAULT;
6605 retval = ixj_init_filter(j, &jf);
6606 break;
6607 case IXJCTL_SET_FILTER_RAW:
6608 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6609 retval = -EFAULT;
6610 else
6611 retval = ixj_init_filter_raw(j, &jfr);
6612 break;
6613 case IXJCTL_GET_FILTER_HIST:
6614 if(arg<0||arg>3)
6615 retval = -EINVAL;
6616 else
6617 retval = j->filter_hist[arg];
6618 break;
6619 case IXJCTL_INIT_TONE:
6620 if (copy_from_user(&ti, argp, sizeof(ti)))
6621 retval = -EFAULT;
6622 else
6623 retval = ixj_init_tone(j, &ti);
6624 break;
6625 case IXJCTL_TONE_CADENCE:
6626 retval = ixj_build_cadence(j, argp);
6627 break;
6628 case IXJCTL_FILTER_CADENCE:
6629 retval = ixj_build_filter_cadence(j, argp);
6630 break;
6631 case IXJCTL_SIGCTL:
6632 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6633 retval = -EFAULT;
6634 break;
6635 }
6636 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6637 if(j->sigdef.event < 33) {
6638 raise = 1;
6639 for(mant = 0; mant < j->sigdef.event; mant++){
6640 raise *= 2;
6641 }
6642 if(j->sigdef.signal)
6643 j->ex_sig.bytes |= raise;
6644 else
6645 j->ex_sig.bytes &= (raise^0xffff);
6646 }
6647 break;
6648 case IXJCTL_INTERCOM_STOP:
6649 if(arg < 0 || arg >= IXJMAX)
6650 return -EINVAL;
6651 j->intercom = -1;
6652 ixj_record_stop(j);
6653 ixj_play_stop(j);
6654 idle(j);
6655 get_ixj(arg)->intercom = -1;
6656 ixj_record_stop(get_ixj(arg));
6657 ixj_play_stop(get_ixj(arg));
6658 idle(get_ixj(arg));
6659 break;
6660 case IXJCTL_INTERCOM_START:
6661 if(arg < 0 || arg >= IXJMAX)
6662 return -EINVAL;
6663 j->intercom = arg;
6664 ixj_record_start(j);
6665 ixj_play_start(j);
6666 get_ixj(arg)->intercom = board;
6667 ixj_play_start(get_ixj(arg));
6668 ixj_record_start(get_ixj(arg));
6669 break;
6670 }
6671 if (ixjdebug & 0x0040)
6672 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6673 clear_bit(board, &j->busyflags);
6674 return retval;
6675 }
6676
6677 static int ixj_fasync(int fd, struct file *file_p, int mode)
6678 {
6679 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6680
6681 return fasync_helper(fd, file_p, mode, &j->async_queue);
6682 }
6683
6684 static struct file_operations ixj_fops =
6685 {
6686 .owner = THIS_MODULE,
6687 .read = ixj_enhanced_read,
6688 .write = ixj_enhanced_write,
6689 .poll = ixj_poll,
6690 .ioctl = ixj_ioctl,
6691 .release = ixj_release,
6692 .fasync = ixj_fasync
6693 };
6694
6695 static int ixj_linetest(IXJ *j)
6696 {
6697 unsigned long jifwait;
6698
6699 j->flags.pstncheck = 1; /* Testing */
6700 j->flags.pstn_present = 0; /* Assume the line is not there */
6701
6702 daa_int_read(j); /*Clear DAA Interrupt flags */
6703 /* */
6704 /* Hold all relays in the normally de-energized position. */
6705 /* */
6706
6707 j->pld_slicw.bits.rly1 = 0;
6708 j->pld_slicw.bits.rly2 = 0;
6709 j->pld_slicw.bits.rly3 = 0;
6710 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6711 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6712
6713 outb_p(j->pld_scrw.byte, j->XILINXbase);
6714 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6715 if (j->pld_slicr.bits.potspstn) {
6716 j->flags.pots_pstn = 1;
6717 j->flags.pots_correct = 0;
6718 LED_SetState(0x4, j);
6719 } else {
6720 j->flags.pots_pstn = 0;
6721 j->pld_slicw.bits.rly1 = 0;
6722 j->pld_slicw.bits.rly2 = 0;
6723 j->pld_slicw.bits.rly3 = 1;
6724 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6725 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6726
6727 outb_p(j->pld_scrw.byte, j->XILINXbase);
6728 daa_set_mode(j, SOP_PU_CONVERSATION);
6729 jifwait = jiffies + hertz;
6730 while (time_before(jiffies, jifwait)) {
6731 set_current_state(TASK_INTERRUPTIBLE);
6732 schedule_timeout(1);
6733 }
6734 daa_int_read(j);
6735 daa_set_mode(j, SOP_PU_RESET);
6736 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6737 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6738 LED_SetState(0x4, j);
6739 j->pld_slicw.bits.rly3 = 0;
6740 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6741 } else {
6742 j->flags.pots_correct = 1;
6743 LED_SetState(0x8, j);
6744 j->pld_slicw.bits.rly1 = 1;
6745 j->pld_slicw.bits.rly2 = 0;
6746 j->pld_slicw.bits.rly3 = 0;
6747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6748 }
6749 }
6750 j->pld_slicw.bits.rly3 = 0;
6751 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6752 daa_set_mode(j, SOP_PU_CONVERSATION);
6753 jifwait = jiffies + hertz;
6754 while (time_before(jiffies, jifwait)) {
6755 set_current_state(TASK_INTERRUPTIBLE);
6756 schedule_timeout(1);
6757 }
6758 daa_int_read(j);
6759 daa_set_mode(j, SOP_PU_RESET);
6760 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6761 j->pstn_sleeptil = jiffies + (hertz / 4);
6762 j->flags.pstn_present = 1;
6763 } else {
6764 j->flags.pstn_present = 0;
6765 }
6766 if (j->flags.pstn_present) {
6767 if (j->flags.pots_correct) {
6768 LED_SetState(0xA, j);
6769 } else {
6770 LED_SetState(0x6, j);
6771 }
6772 } else {
6773 if (j->flags.pots_correct) {
6774 LED_SetState(0x9, j);
6775 } else {
6776 LED_SetState(0x5, j);
6777 }
6778 }
6779 j->flags.pstncheck = 0; /* Testing */
6780 return j->flags.pstn_present;
6781 }
6782
6783 static int ixj_selfprobe(IXJ *j)
6784 {
6785 unsigned short cmd;
6786 unsigned long jif;
6787 int cnt;
6788 BYTES bytes;
6789
6790 init_waitqueue_head(&j->poll_q);
6791 init_waitqueue_head(&j->read_q);
6792 init_waitqueue_head(&j->write_q);
6793
6794 while(atomic_read(&j->DSPWrite) > 0)
6795 atomic_dec(&j->DSPWrite);
6796 if (ixjdebug & 0x0002)
6797 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6798 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6799
6800 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6801 return -1;
6802 /* The read values of the SSR should be 0x00 for the IDLE command */
6803 if (j->ssr.low || j->ssr.high)
6804 return -1;
6805 if (ixjdebug & 0x0002)
6806 printk(KERN_INFO "Get Device ID Code\n");
6807 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6808 return -1;
6809 j->dsp.low = j->ssr.low;
6810 j->dsp.high = j->ssr.high;
6811 if (ixjdebug & 0x0002)
6812 printk(KERN_INFO "Get Device Version Code\n");
6813 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6814 return -1;
6815 j->ver.low = j->ssr.low;
6816 j->ver.high = j->ssr.high;
6817 if (!j->cardtype) {
6818 if (j->dsp.low == 0x21) {
6819 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6820 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6821 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6822 bytes.low = inb_p(j->XILINXbase + 0x02);
6823 if (bytes.low == bytes.high) /* Register is read only on */
6824 /* Internet PhoneJack Lite */
6825 {
6826 j->cardtype = QTI_PHONEJACK_LITE;
6827 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6828 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6829 return -1;
6830 }
6831 j->pld_slicw.pcib.e1 = 1;
6832 outb_p(j->pld_slicw.byte, j->XILINXbase);
6833 } else {
6834 j->cardtype = QTI_LINEJACK;
6835
6836 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6837 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6838 return -1;
6839 }
6840 }
6841 } else if (j->dsp.low == 0x22) {
6842 j->cardtype = QTI_PHONEJACK_PCI;
6843 request_region(j->XILINXbase, 4, "ixj control");
6844 j->pld_slicw.pcib.e1 = 1;
6845 outb_p(j->pld_slicw.byte, j->XILINXbase);
6846 } else
6847 j->cardtype = QTI_PHONEJACK;
6848 } else {
6849 switch (j->cardtype) {
6850 case QTI_PHONEJACK:
6851 if (!j->dsp.low != 0x20) {
6852 j->dsp.high = 0x80;
6853 j->dsp.low = 0x20;
6854 ixj_WriteDSPCommand(0x3800, j);
6855 j->ver.low = j->ssr.low;
6856 j->ver.high = j->ssr.high;
6857 }
6858 break;
6859 case QTI_LINEJACK:
6860 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6861 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6862 return -1;
6863 }
6864 break;
6865 case QTI_PHONEJACK_LITE:
6866 case QTI_PHONEJACK_PCI:
6867 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6868 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6869 return -1;
6870 }
6871 j->pld_slicw.pcib.e1 = 1;
6872 outb_p(j->pld_slicw.byte, j->XILINXbase);
6873 break;
6874 case QTI_PHONECARD:
6875 break;
6876 }
6877 }
6878 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6879 if (ixjdebug & 0x0002)
6880 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6881 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6882 return -1;
6883 if (ixjdebug & 0x0002)
6884 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6885 if (j->cardtype == QTI_PHONEJACK) {
6886 cmd = 0x9FF2;
6887 } else {
6888 cmd = 0x9FF5;
6889 }
6890 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6891 return -1;
6892 } else {
6893 if (set_base_frame(j, 30) != 30)
6894 return -1;
6895 if (ixjdebug & 0x0002)
6896 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6897 if (j->cardtype == QTI_PHONECARD) {
6898 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6899 return -1;
6900 }
6901 if (j->cardtype == QTI_LINEJACK) {
6902 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6903 return -1;
6904 if (ixjdebug & 0x0002)
6905 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6906 j->pld_clock.byte = 0;
6907 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6908 }
6909 }
6910
6911 if (j->dsp.low == 0x20) {
6912 if (ixjdebug & 0x0002)
6913 printk(KERN_INFO "Configure GPIO pins\n");
6914 j->gpio.bytes.high = 0x09;
6915 /* bytes.low = 0xEF; 0xF7 */
6916 j->gpio.bits.gpio1 = 1;
6917 j->gpio.bits.gpio2 = 1;
6918 j->gpio.bits.gpio3 = 0;
6919 j->gpio.bits.gpio4 = 1;
6920 j->gpio.bits.gpio5 = 1;
6921 j->gpio.bits.gpio6 = 1;
6922 j->gpio.bits.gpio7 = 1;
6923 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6924 if (ixjdebug & 0x0002)
6925 printk(KERN_INFO "Enable SLIC\n");
6926 j->gpio.bytes.high = 0x0B;
6927 j->gpio.bytes.low = 0x00;
6928 j->gpio.bits.gpio1 = 0;
6929 j->gpio.bits.gpio2 = 1;
6930 j->gpio.bits.gpio5 = 0;
6931 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6932 j->port = PORT_POTS;
6933 } else {
6934 if (j->cardtype == QTI_LINEJACK) {
6935 LED_SetState(0x1, j);
6936 jif = jiffies + (hertz / 10);
6937 while (time_before(jiffies, jif)) {
6938 set_current_state(TASK_INTERRUPTIBLE);
6939 schedule_timeout(1);
6940 }
6941 LED_SetState(0x2, j);
6942 jif = jiffies + (hertz / 10);
6943 while (time_before(jiffies, jif)) {
6944 set_current_state(TASK_INTERRUPTIBLE);
6945 schedule_timeout(1);
6946 }
6947 LED_SetState(0x4, j);
6948 jif = jiffies + (hertz / 10);
6949 while (time_before(jiffies, jif)) {
6950 set_current_state(TASK_INTERRUPTIBLE);
6951 schedule_timeout(1);
6952 }
6953 LED_SetState(0x8, j);
6954 jif = jiffies + (hertz / 10);
6955 while (time_before(jiffies, jif)) {
6956 set_current_state(TASK_INTERRUPTIBLE);
6957 schedule_timeout(1);
6958 }
6959 LED_SetState(0x0, j);
6960 daa_get_version(j);
6961 if (ixjdebug & 0x0002)
6962 printk("Loading DAA Coefficients\n");
6963 DAA_Coeff_US(j);
6964 if (!ixj_daa_write(j)) {
6965 printk("DAA write failed on board %d\n", j->board);
6966 return -1;
6967 }
6968 if(!ixj_daa_cid_reset(j)) {
6969 printk("DAA CID reset failed on board %d\n", j->board);
6970 return -1;
6971 }
6972 j->flags.pots_correct = 0;
6973 j->flags.pstn_present = 0;
6974 ixj_linetest(j);
6975 if (j->flags.pots_correct) {
6976 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6977
6978 outb_p(j->pld_scrw.byte, j->XILINXbase);
6979 j->pld_slicw.bits.rly1 = 1;
6980 j->pld_slicw.bits.spken = 1;
6981 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6982 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6983 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6984 j->port = PORT_POTS;
6985 }
6986 ixj_set_port(j, PORT_PSTN);
6987 ixj_set_pots(j, 1);
6988 if (ixjdebug & 0x0002)
6989 printk(KERN_INFO "Enable Mixer\n");
6990 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6991 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6992
6993 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6994 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6995
6996 ixj_mixer(0x0480, j); /*FM Left mute */
6997 ixj_mixer(0x0580, j); /*FM Right mute */
6998
6999 ixj_mixer(0x0680, j); /*CD Left mute */
7000 ixj_mixer(0x0780, j); /*CD Right mute */
7001
7002 ixj_mixer(0x0880, j); /*Line Left mute */
7003 ixj_mixer(0x0980, j); /*Line Right mute */
7004
7005 ixj_mixer(0x0A80, j); /*Aux left mute */
7006 ixj_mixer(0x0B80, j); /*Aux right mute */
7007
7008 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
7009 ixj_mixer(0x0D80, j); /*Mono2 mute */
7010
7011 ixj_mixer(0x0E80, j); /*Mic mute */
7012
7013 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
7014
7015 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
7016 ixj_mixer(0x110C, j);
7017
7018
7019 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
7020 ixj_mixer(0x1401, j);
7021
7022 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
7023 ixj_mixer(0x1501, j);
7024
7025 ixj_mixer(0x1700, j); /*Clock select */
7026
7027 ixj_mixer(0x1800, j); /*ADC input from mixer */
7028
7029 ixj_mixer(0x1901, j); /*Mic gain 30db */
7030
7031 if (ixjdebug & 0x0002)
7032 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7033 j->cadence_f[4].state = 0;
7034 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7035 j->cadence_f[4].off1 = 0;
7036 j->cadence_f[4].on2 = 0;
7037 j->cadence_f[4].off2 = 0;
7038 j->cadence_f[4].on3 = 0;
7039 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7040 j->pstn_last_rmr = jiffies;
7041
7042 } else {
7043 if (j->cardtype == QTI_PHONECARD) {
7044 ixj_WriteDSPCommand(0xCF07, j);
7045 ixj_WriteDSPCommand(0x00B0, j);
7046 ixj_set_port(j, PORT_SPEAKER);
7047 } else {
7048 ixj_set_port(j, PORT_POTS);
7049 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7050 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7051 }
7052 }
7053 }
7054
7055 j->intercom = -1;
7056 j->framesread = j->frameswritten = 0;
7057 j->read_wait = j->write_wait = 0;
7058 j->rxreadycheck = j->txreadycheck = 0;
7059
7060 /* initialise the DTMF prescale to a sensible value */
7061 if (j->cardtype == QTI_LINEJACK) {
7062 set_dtmf_prescale(j, 0x10);
7063 } else {
7064 set_dtmf_prescale(j, 0x40);
7065 }
7066 set_play_volume(j, 0x100);
7067 set_rec_volume(j, 0x100);
7068
7069 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7070 return -1;
7071 /* The read values of the SSR should be 0x00 for the IDLE command */
7072 if (j->ssr.low || j->ssr.high)
7073 return -1;
7074
7075 if (ixjdebug & 0x0002)
7076 printk(KERN_INFO "Enable Line Monitor\n");
7077
7078 if (ixjdebug & 0x0002)
7079 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7080
7081 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7082 return -1;
7083
7084 if (ixjdebug & 0x002)
7085 printk(KERN_INFO "Enable DTMF Detectors\n");
7086
7087 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7088 return -1;
7089
7090 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7091 return -1;
7092
7093 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7094
7095 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7096
7097 j->ex.bits.dtmf_ready = 0;
7098 j->dtmf_state = 0;
7099 j->dtmf_wp = j->dtmf_rp = 0;
7100 j->rec_mode = j->play_mode = -1;
7101 j->flags.ringing = 0;
7102 j->maxrings = MAXRINGS;
7103 j->ring_cadence = USA_RING_CADENCE;
7104 j->drybuffer = 0;
7105 j->winktime = 320;
7106 j->flags.dtmf_oob = 0;
7107 for (cnt = 0; cnt < 4; cnt++)
7108 j->cadence_f[cnt].enable = 0;
7109 /* must be a device on the specified address */
7110 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7111
7112 /* Set up the default signals for events */
7113 for (cnt = 0; cnt < 35; cnt++)
7114 j->ixj_signals[cnt] = SIGIO;
7115
7116 /* Set the excetion signal enable flags */
7117 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7118 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 =
7119 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;
7120 #ifdef IXJ_DYN_ALLOC
7121 j->fskdata = NULL;
7122 #endif
7123 j->fskdcnt = 0;
7124 j->cidcw_wait = 0;
7125
7126 /* Register with the Telephony for Linux subsystem */
7127 j->p.f_op = &ixj_fops;
7128 j->p.open = ixj_open;
7129 j->p.board = j->board;
7130 phone_register_device(&j->p, PHONE_UNIT_ANY);
7131
7132 ixj_init_timer(j);
7133 ixj_add_timer(j);
7134 return 0;
7135 }
7136
7137 /*
7138 * Exported service for pcmcia card handling
7139 */
7140
7141 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7142 {
7143 IXJ *j = ixj_alloc();
7144
7145 j->board = 0;
7146
7147 j->DSPbase = dsp;
7148 j->XILINXbase = xilinx;
7149 j->cardtype = QTI_PHONECARD;
7150 ixj_selfprobe(j);
7151 return j;
7152 }
7153
7154 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7155
7156 static int ixj_get_status_proc(char *buf)
7157 {
7158 int len;
7159 int cnt;
7160 IXJ *j;
7161 len = 0;
7162 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7163 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7164 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7165 len += sprintf(buf + len, "\nUsing old telephony API");
7166 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7167
7168 for (cnt = 0; cnt < IXJMAX; cnt++) {
7169 j = get_ixj(cnt);
7170 if(j==NULL)
7171 continue;
7172 if (j->DSPbase) {
7173 len += sprintf(buf + len, "\nCard Num %d", cnt);
7174 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7175 if (j->cardtype != QTI_PHONEJACK)
7176 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7177 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7178 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7179 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7180 switch (j->cardtype) {
7181 case (QTI_PHONEJACK):
7182 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7183 break;
7184 case (QTI_LINEJACK):
7185 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7186 if (j->flags.g729_loaded)
7187 len += sprintf(buf + len, " w/G.729 A/B");
7188 len += sprintf(buf + len, " Country = %d", j->daa_country);
7189 break;
7190 case (QTI_PHONEJACK_LITE):
7191 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7192 if (j->flags.g729_loaded)
7193 len += sprintf(buf + len, " w/G.729 A/B");
7194 break;
7195 case (QTI_PHONEJACK_PCI):
7196 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7197 if (j->flags.g729_loaded)
7198 len += sprintf(buf + len, " w/G.729 A/B");
7199 break;
7200 case (QTI_PHONECARD):
7201 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7202 if (j->flags.g729_loaded)
7203 len += sprintf(buf + len, " w/G.729 A/B");
7204 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7205 if (!j->pccr1.bits.drf)
7206 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7207 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7208 break;
7209 default:
7210 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7211 break;
7212 }
7213 len += sprintf(buf + len, "\nReaders %d", j->readers);
7214 len += sprintf(buf + len, "\nWriters %d", j->writers);
7215 add_caps(j);
7216 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7217 if (j->dsp.low != 0x20)
7218 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7219 if (j->flags.cidsent)
7220 len += sprintf(buf + len, "\nCaller ID data sent");
7221 else
7222 len += sprintf(buf + len, "\nCaller ID data not sent");
7223
7224 len += sprintf(buf + len, "\nPlay CODEC ");
7225 switch (j->play_codec) {
7226 case G723_63:
7227 len += sprintf(buf + len, "G.723.1 6.3");
7228 break;
7229 case G723_53:
7230 len += sprintf(buf + len, "G.723.1 5.3");
7231 break;
7232 case TS85:
7233 len += sprintf(buf + len, "TrueSpeech 8.5");
7234 break;
7235 case TS48:
7236 len += sprintf(buf + len, "TrueSpeech 4.8");
7237 break;
7238 case TS41:
7239 len += sprintf(buf + len, "TrueSpeech 4.1");
7240 break;
7241 case G728:
7242 len += sprintf(buf + len, "G.728");
7243 break;
7244 case G729:
7245 len += sprintf(buf + len, "G.729");
7246 break;
7247 case G729B:
7248 len += sprintf(buf + len, "G.729B");
7249 break;
7250 case ULAW:
7251 len += sprintf(buf + len, "uLaw");
7252 break;
7253 case ALAW:
7254 len += sprintf(buf + len, "aLaw");
7255 break;
7256 case LINEAR16:
7257 len += sprintf(buf + len, "16 bit Linear");
7258 break;
7259 case LINEAR8:
7260 len += sprintf(buf + len, "8 bit Linear");
7261 break;
7262 case WSS:
7263 len += sprintf(buf + len, "Windows Sound System");
7264 break;
7265 default:
7266 len += sprintf(buf + len, "NO CODEC CHOSEN");
7267 break;
7268 }
7269 len += sprintf(buf + len, "\nRecord CODEC ");
7270 switch (j->rec_codec) {
7271 case G723_63:
7272 len += sprintf(buf + len, "G.723.1 6.3");
7273 break;
7274 case G723_53:
7275 len += sprintf(buf + len, "G.723.1 5.3");
7276 break;
7277 case TS85:
7278 len += sprintf(buf + len, "TrueSpeech 8.5");
7279 break;
7280 case TS48:
7281 len += sprintf(buf + len, "TrueSpeech 4.8");
7282 break;
7283 case TS41:
7284 len += sprintf(buf + len, "TrueSpeech 4.1");
7285 break;
7286 case G728:
7287 len += sprintf(buf + len, "G.728");
7288 break;
7289 case G729:
7290 len += sprintf(buf + len, "G.729");
7291 break;
7292 case G729B:
7293 len += sprintf(buf + len, "G.729B");
7294 break;
7295 case ULAW:
7296 len += sprintf(buf + len, "uLaw");
7297 break;
7298 case ALAW:
7299 len += sprintf(buf + len, "aLaw");
7300 break;
7301 case LINEAR16:
7302 len += sprintf(buf + len, "16 bit Linear");
7303 break;
7304 case LINEAR8:
7305 len += sprintf(buf + len, "8 bit Linear");
7306 break;
7307 case WSS:
7308 len += sprintf(buf + len, "Windows Sound System");
7309 break;
7310 default:
7311 len += sprintf(buf + len, "NO CODEC CHOSEN");
7312 break;
7313 }
7314 len += sprintf(buf + len, "\nAEC ");
7315 switch (j->aec_level) {
7316 case AEC_OFF:
7317 len += sprintf(buf + len, "Off");
7318 break;
7319 case AEC_LOW:
7320 len += sprintf(buf + len, "Low");
7321 break;
7322 case AEC_MED:
7323 len += sprintf(buf + len, "Med");
7324 break;
7325 case AEC_HIGH:
7326 len += sprintf(buf + len, "High");
7327 break;
7328 case AEC_AUTO:
7329 len += sprintf(buf + len, "Auto");
7330 break;
7331 case AEC_AGC:
7332 len += sprintf(buf + len, "AEC/AGC");
7333 break;
7334 default:
7335 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7336 break;
7337 }
7338
7339 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7340 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7341 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7342
7343 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7344
7345 if (j->cardtype == QTI_LINEJACK) {
7346 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7347 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7348 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7349 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7350 switch (j->daa_mode) {
7351 case SOP_PU_SLEEP:
7352 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7353 break;
7354 case SOP_PU_RINGING:
7355 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7356 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7357 break;
7358 case SOP_PU_CONVERSATION:
7359 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7360 break;
7361 case SOP_PU_PULSEDIALING:
7362 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7363 break;
7364 }
7365 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7366 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7367 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7368 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7369 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7370 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7371 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7372 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7373 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7374 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7375 }
7376 switch (j->port) {
7377 case PORT_POTS:
7378 len += sprintf(buf + len, "\nPort POTS");
7379 break;
7380 case PORT_PSTN:
7381 len += sprintf(buf + len, "\nPort PSTN");
7382 break;
7383 case PORT_SPEAKER:
7384 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7385 break;
7386 case PORT_HANDSET:
7387 len += sprintf(buf + len, "\nPort HANDSET");
7388 break;
7389 }
7390 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7391 len += sprintf(buf + len, "\nSLIC state ");
7392 switch (SLIC_GetState(j)) {
7393 case PLD_SLIC_STATE_OC:
7394 len += sprintf(buf + len, "OC");
7395 break;
7396 case PLD_SLIC_STATE_RINGING:
7397 len += sprintf(buf + len, "RINGING");
7398 break;
7399 case PLD_SLIC_STATE_ACTIVE:
7400 len += sprintf(buf + len, "ACTIVE");
7401 break;
7402 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7403 len += sprintf(buf + len, "OHT");
7404 break;
7405 case PLD_SLIC_STATE_TIPOPEN:
7406 len += sprintf(buf + len, "TIPOPEN");
7407 break;
7408 case PLD_SLIC_STATE_STANDBY:
7409 len += sprintf(buf + len, "STANDBY");
7410 break;
7411 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7412 len += sprintf(buf + len, "APR");
7413 break;
7414 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7415 len += sprintf(buf + len, "OHTPR");
7416 break;
7417 default:
7418 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7419 break;
7420 }
7421 }
7422 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7423 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7424 #ifdef PERFMON_STATS
7425 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7426 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7427 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7428 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7429 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7430 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7431 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7432 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7433 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7434 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7435 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7436 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7437 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7438 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7439
7440 #endif
7441 len += sprintf(buf + len, "\n");
7442 }
7443 }
7444 return len;
7445 }
7446
7447 static int ixj_read_proc(char *page, char **start, off_t off,
7448 int count, int *eof, void *data)
7449 {
7450 int len = ixj_get_status_proc(page);
7451 if (len <= off+count) *eof = 1;
7452 *start = page + off;
7453 len -= off;
7454 if (len>count) len = count;
7455 if (len<0) len = 0;
7456 return len;
7457 }
7458
7459
7460 static void cleanup(void)
7461 {
7462 int cnt;
7463 IXJ *j;
7464
7465 for (cnt = 0; cnt < IXJMAX; cnt++) {
7466 j = get_ixj(cnt);
7467 if(j != NULL && j->DSPbase) {
7468 if (ixjdebug & 0x0002)
7469 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7470 del_timer(&j->timer);
7471 if (j->cardtype == QTI_LINEJACK) {
7472 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7473
7474 outb_p(j->pld_scrw.byte, j->XILINXbase);
7475 j->pld_slicw.bits.rly1 = 0;
7476 j->pld_slicw.bits.rly2 = 0;
7477 j->pld_slicw.bits.rly3 = 0;
7478 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7479 LED_SetState(0x0, j);
7480 if (ixjdebug & 0x0002)
7481 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7482 release_region(j->XILINXbase, 8);
7483 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7484 if (ixjdebug & 0x0002)
7485 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7486 release_region(j->XILINXbase, 4);
7487 }
7488 kfree(j->read_buffer);
7489 kfree(j->write_buffer);
7490 if (j->dev)
7491 pnp_device_detach(j->dev);
7492 if (ixjdebug & 0x0002)
7493 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7494 phone_unregister_device(&j->p);
7495 if (ixjdebug & 0x0002)
7496 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7497 release_region(j->DSPbase, 16);
7498 #ifdef IXJ_DYN_ALLOC
7499 if (ixjdebug & 0x0002)
7500 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7501 kfree(j);
7502 ixj[cnt] = NULL;
7503 #endif
7504 }
7505 }
7506 if (ixjdebug & 0x0002)
7507 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7508 remove_proc_entry ("ixj", NULL);
7509 }
7510
7511 /* Typedefs */
7512 typedef struct {
7513 BYTE length;
7514 DWORD bits;
7515 } DATABLOCK;
7516
7517 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7518 {
7519 lastLCC = lastLCC & 0xfb;
7520 lastLCC = lastLCC | (byData ? 4 : 0);
7521 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7522
7523 mdelay(1);
7524 lastLCC = lastLCC | 0x01;
7525 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7526
7527 byData = byData << 1;
7528 lastLCC = lastLCC & 0xfe;
7529 mdelay(1);
7530 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7531
7532 }
7533
7534 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7535 {
7536 mdelay(1);
7537 lastLCC = lastLCC | 0x01;
7538 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7539
7540 lastLCC = lastLCC & 0xfe;
7541 mdelay(1);
7542 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7543
7544 return ((inb(wEEPROMAddress) >> 3) & 1);
7545 }
7546
7547 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7548 {
7549 BYTE lastLCC;
7550 WORD wEEPROMAddress = wAddress + 3;
7551 DWORD i;
7552 BYTE byResult;
7553 *pwResult = 0;
7554 lastLCC = inb(wEEPROMAddress);
7555 lastLCC = lastLCC | 0x02;
7556 lastLCC = lastLCC & 0xfe;
7557 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7558
7559 mdelay(1); /* delay */
7560
7561 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7562 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7563 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7564 for (i = 0; i < 8; i++) {
7565 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7566 wLoc <<= 1;
7567 }
7568
7569 for (i = 0; i < 16; i++) {
7570 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7571 *pwResult = (*pwResult << 1) | byResult;
7572 }
7573
7574 mdelay(1); /* another delay */
7575
7576 lastLCC = lastLCC & 0xfd;
7577 outb(lastLCC, wEEPROMAddress); /* negate CS */
7578
7579 return 0;
7580 }
7581
7582 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7583 {
7584 WORD wLo, wHi;
7585 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7586 return 0;
7587 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7588 return 0;
7589 return (((DWORD) wHi << 16) | wLo);
7590 }
7591
7592 static int dspio[IXJMAX + 1] =
7593 {
7594 0,
7595 };
7596 static int xio[IXJMAX + 1] =
7597 {
7598 0,
7599 };
7600
7601 module_param_array(dspio, int, NULL, 0);
7602 module_param_array(xio, int, NULL, 0);
7603 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7604 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7605 MODULE_LICENSE("GPL");
7606
7607 static void __exit ixj_exit(void)
7608 {
7609 cleanup();
7610 }
7611
7612 static IXJ *new_ixj(unsigned long port)
7613 {
7614 IXJ *res;
7615 if (!request_region(port, 16, "ixj DSP")) {
7616 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7617 return NULL;
7618 }
7619 res = ixj_alloc();
7620 if (!res) {
7621 release_region(port, 16);
7622 printk(KERN_INFO "ixj: out of memory\n");
7623 return NULL;
7624 }
7625 res->DSPbase = port;
7626 return res;
7627 }
7628
7629 static int __init ixj_probe_isapnp(int *cnt)
7630 {
7631 int probe = 0;
7632 int func = 0x110;
7633 struct pnp_dev *dev = NULL, *old_dev = NULL;
7634
7635 while (1) {
7636 do {
7637 IXJ *j;
7638 int result;
7639
7640 old_dev = dev;
7641 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7642 ISAPNP_FUNCTION(func), old_dev);
7643 if (!dev || !dev->card)
7644 break;
7645 result = pnp_device_attach(dev);
7646 if (result < 0) {
7647 printk("pnp attach failed %d \n", result);
7648 break;
7649 }
7650 if (pnp_activate_dev(dev) < 0) {
7651 printk("pnp activate failed (out of resources?)\n");
7652 pnp_device_detach(dev);
7653 return -ENOMEM;
7654 }
7655
7656 if (!pnp_port_valid(dev, 0)) {
7657 pnp_device_detach(dev);
7658 return -ENODEV;
7659 }
7660
7661 j = new_ixj(pnp_port_start(dev, 0));
7662 if (!j)
7663 break;
7664
7665 if (func != 0x110)
7666 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7667
7668 switch (func) {
7669 case (0x110):
7670 j->cardtype = QTI_PHONEJACK;
7671 break;
7672 case (0x310):
7673 j->cardtype = QTI_LINEJACK;
7674 break;
7675 case (0x410):
7676 j->cardtype = QTI_PHONEJACK_LITE;
7677 break;
7678 }
7679 j->board = *cnt;
7680 probe = ixj_selfprobe(j);
7681 if(!probe) {
7682 j->serial = dev->card->serial;
7683 j->dev = dev;
7684 switch (func) {
7685 case 0x110:
7686 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7687 break;
7688 case 0x310:
7689 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7690 break;
7691 case 0x410:
7692 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7693 break;
7694 }
7695 }
7696 ++*cnt;
7697 } while (dev);
7698 if (func == 0x410)
7699 break;
7700 if (func == 0x310)
7701 func = 0x410;
7702 if (func == 0x110)
7703 func = 0x310;
7704 dev = NULL;
7705 }
7706 return probe;
7707 }
7708
7709 static int __init ixj_probe_isa(int *cnt)
7710 {
7711 int i, probe;
7712
7713 /* Use passed parameters for older kernels without PnP */
7714 for (i = 0; i < IXJMAX; i++) {
7715 if (dspio[i]) {
7716 IXJ *j = new_ixj(dspio[i]);
7717
7718 if (!j)
7719 break;
7720
7721 j->XILINXbase = xio[i];
7722 j->cardtype = 0;
7723
7724 j->board = *cnt;
7725 probe = ixj_selfprobe(j);
7726 j->dev = NULL;
7727 ++*cnt;
7728 }
7729 }
7730 return 0;
7731 }
7732
7733 static int __init ixj_probe_pci(int *cnt)
7734 {
7735 struct pci_dev *pci = NULL;
7736 int i, probe = 0;
7737 IXJ *j = NULL;
7738
7739 for (i = 0; i < IXJMAX - *cnt; i++) {
7740 pci = pci_find_device(0x15E2, 0x0500, pci);
7741 if (!pci)
7742 break;
7743
7744 if (pci_enable_device(pci))
7745 break;
7746 j = new_ixj(pci_resource_start(pci, 0));
7747 if (!j)
7748 break;
7749
7750 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7751 j->XILINXbase = j->DSPbase + 0x10;
7752 j->cardtype = QTI_PHONEJACK_PCI;
7753 j->board = *cnt;
7754 probe = ixj_selfprobe(j);
7755 if (!probe)
7756 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7757 ++*cnt;
7758 }
7759 return probe;
7760 }
7761
7762 static int __init ixj_init(void)
7763 {
7764 int cnt = 0;
7765 int probe = 0;
7766
7767 cnt = 0;
7768
7769 /* These might be no-ops, see above. */
7770 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7771 return probe;
7772 }
7773 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7774 return probe;
7775 }
7776 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7777 return probe;
7778 }
7779 printk(KERN_INFO "ixj driver initialized.\n");
7780 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7781 return probe;
7782 }
7783
7784 module_init(ixj_init);
7785 module_exit(ixj_exit);
7786
7787 static void DAA_Coeff_US(IXJ *j)
7788 {
7789 int i;
7790
7791 j->daa_country = DAA_US;
7792 /*----------------------------------------------- */
7793 /* CAO */
7794 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7795 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7796 }
7797
7798 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7799 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7800 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7801 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7802 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7803 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7804 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7805 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7806 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7807 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7808 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7809 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7810 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7811 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7812 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7813 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7814 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7815 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7816 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7817 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7818 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7819 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7820 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7821 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7822 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7823 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7824 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7825 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7826 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7827 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7828 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7829 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7830 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7831 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7832 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7833 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7834 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7835 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7836 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7837 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7838 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7839 /* Bytes for AR-filter (09): 52,D3,11,42 */
7840 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7841 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7842 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7843 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7844 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7845 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7846 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7847 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7848 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7849 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7850 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7851 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7852 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7853 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7854 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7855 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7856 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7857 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7858 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7859 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7860 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7861 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7862 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7863 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7864 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7865 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7866 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7867 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7868 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7869 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7870 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7871 /* ; (10K, 0.68uF) */
7872 /* */
7873 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7874 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7875 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7876 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7877 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7878 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7879 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7880 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7881 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7882 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7883 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7884 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7885 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7886 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7887 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7888 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7889 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7890 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7891
7892 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7893 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7894 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7895 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7896 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7897
7898 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7899 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7900 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7901 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7902 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7903 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7904 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7905 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7906 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7907 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7908 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7909 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7910 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7911 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7912 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7913 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7914 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7915 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7916 /* */
7917 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7918 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7919 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7920 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7921 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7922
7923 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7924 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7925 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7926 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7927 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7928 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7929 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7930 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7931 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7932 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7933 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7934 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7935 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7936 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7937 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7938 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7939 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7940 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7941 /* */
7942 /* ;CR Registers */
7943 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7944 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7945 /* Config. Reg. 1 (dialing) (cr1):05 */
7946 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7947 /* Config. Reg. 2 (caller ID) (cr2):04 */
7948 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7949 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7950 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7951 /* Config. Reg. 4 (analog gain) (cr4):02 */
7952 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7953 /* Config. Reg. 5 (Version) (cr5):02 */
7954 /* Config. Reg. 6 (Reserved) (cr6):00 */
7955 /* Config. Reg. 7 (Reserved) (cr7):00 */
7956 /* */
7957 /* ;xr Registers */
7958 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7959
7960 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7961 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7962
7963 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7964 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7965 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7966 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7967 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7968 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7969
7970 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7971 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7972 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7973 /* Ext. Reg. 6 (Power State) (xr6):00 */
7974 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7975 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7976 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7977 /* */
7978 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7979 /* 12,33,5A,C3 ; 770 Hz */
7980 /* 13,3C,5B,32 ; 852 Hz */
7981 /* 1D,1B,5C,CC ; 941 Hz */
7982
7983 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7984 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7985 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7986 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7987 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7988 /* EC,1D,52,22 ; 1336 Hz */
7989 /* AA,AC,51,D2 ; 1477 Hz */
7990 /* 9B,3B,51,25 ; 1633 Hz */
7991 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7992 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7993 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7994 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7995 }
7996
7997 static void DAA_Coeff_UK(IXJ *j)
7998 {
7999 int i;
8000
8001 j->daa_country = DAA_UK;
8002 /*----------------------------------------------- */
8003 /* CAO */
8004 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8005 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8006 }
8007
8008 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8009 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8010 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8011 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8012 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8013 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8014 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8015 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8016 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8017 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8018 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8019 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8020 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8021 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8022 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8023 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8024 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8025 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8026 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
8027 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8028 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8029 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8030 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8031 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8032 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8033 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8034 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8035 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8036 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8037 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8038 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8039 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8040 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8041 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8042 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8043 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8044 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8045 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8046 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8047 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8048 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8049 /* Bytes for AR-filter (09): E2,27,10,D6 */
8050 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8051 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8052 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8053 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8054 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8055 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8056 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8057 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8058 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8059 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8060 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8061 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8062 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8063 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8064 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8065 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8066 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8067 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8068 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8069 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8070 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8071 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8072 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8073 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8074 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8075 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8076 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8077 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8078 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8079 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8080 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8081 /* ; idle */
8082 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8083 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8084 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8085 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8086 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8087 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8088 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8089 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8090 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8091 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8092 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8093 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8094 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8095 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8096 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8097 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8098 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8099 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8100 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8101 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8102 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8103 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8104 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8105 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8106 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8107 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8108 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8109 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8110 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8111 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8112 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8113 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8114 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8115 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8116 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8117 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8118 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8119 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8120 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8121 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8122 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8123 /* ;CR Registers */
8124 /* Config. Reg. 0 (filters) (cr0):FF */
8125 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8126 /* Config. Reg. 1 (dialing) (cr1):05 */
8127 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8128 /* Config. Reg. 2 (caller ID) (cr2):04 */
8129 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8130 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8131 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8132 /* Config. Reg. 4 (analog gain) (cr4):02 */
8133 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8134 /* Config. Reg. 5 (Version) (cr5):02 */
8135 /* Config. Reg. 6 (Reserved) (cr6):00 */
8136 /* Config. Reg. 7 (Reserved) (cr7):00 */
8137 /* ;xr Registers */
8138 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8139
8140 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8141 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8142
8143 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8144 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8145
8146 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8147 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8148 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8149 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8150 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8151 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8152 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8153 /* Ext. Reg. 6 (Power State) (xr6):00 */
8154 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8155 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8156 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8157 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8158 /* 12,33,5A,C3 ; 770 Hz */
8159 /* 13,3C,5B,32 ; 852 Hz */
8160 /* 1D,1B,5C,CC ; 941 Hz */
8161
8162 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8163 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8164 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8165 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8166 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8167 /* EC,1D,52,22 ; 1336 Hz */
8168 /* AA,AC,51,D2 ; 1477 Hz */
8169 /* 9B,3B,51,25 ; 1633 Hz */
8170 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8171 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8172 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8173 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8174 }
8175
8176
8177 static void DAA_Coeff_France(IXJ *j)
8178 {
8179 int i;
8180
8181 j->daa_country = DAA_FRANCE;
8182 /*----------------------------------------------- */
8183 /* CAO */
8184 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8185 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8186 }
8187
8188 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8189 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8190 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8191 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8192 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8193 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8194 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8195 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8196 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8197 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8198 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8199 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8200 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8201 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8202 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8203 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8204 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8205 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8206 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8207 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8208 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8209 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8210 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8211 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8212 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8213 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8214 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8215 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8216 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8217 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8218 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8219 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8220 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8221 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8222 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8223 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8224 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8225 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8226 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8227 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8228 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8229 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8230 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8231 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8232 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8233 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8234 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8235 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8236 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8237 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8238 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8239 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8240 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8241 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8242 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8243 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8244 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8245 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8246 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8247 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8248 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8249 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8250 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8251 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8252 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8253 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8254 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8255 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8256 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8257 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8258 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8259 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8260 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8261 /* ; idle */
8262 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8263 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8264 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8265 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8266 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8267 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8268 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8269 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8270 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8271 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8272 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8273 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8274 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8275 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8276 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8277 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8278 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8279 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8280 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8281 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8282 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8283 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8284 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8285 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8286 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8287 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8288 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8289 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8290 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8291 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8292 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8293 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8294 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8295 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8296 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8297 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8298 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8299 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8300 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8301 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8302 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8303 /* ;CR Registers */
8304 /* Config. Reg. 0 (filters) (cr0):FF */
8305 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8306 /* Config. Reg. 1 (dialing) (cr1):05 */
8307 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8308 /* Config. Reg. 2 (caller ID) (cr2):04 */
8309 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8310 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8311 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8312 /* Config. Reg. 4 (analog gain) (cr4):02 */
8313 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8314 /* Config. Reg. 5 (Version) (cr5):02 */
8315 /* Config. Reg. 6 (Reserved) (cr6):00 */
8316 /* Config. Reg. 7 (Reserved) (cr7):00 */
8317 /* ;xr Registers */
8318 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8319
8320 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8321 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8322
8323 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8324 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8325
8326 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8327 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8328 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8329 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8330 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8331 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8332 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8333 /* Ext. Reg. 6 (Power State) (xr6):00 */
8334 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8335 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8336 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8337 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8338 /* 12,33,5A,C3 ; 770 Hz */
8339 /* 13,3C,5B,32 ; 852 Hz */
8340 /* 1D,1B,5C,CC ; 941 Hz */
8341
8342 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8343 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8344 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8345 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8346 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8347 /* EC,1D,52,22 ; 1336 Hz */
8348 /* AA,AC,51,D2 ; 1477 Hz */
8349 /* 9B,3B,51,25 ; 1633 Hz */
8350 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8351 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8352 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8353 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8354 }
8355
8356
8357 static void DAA_Coeff_Germany(IXJ *j)
8358 {
8359 int i;
8360
8361 j->daa_country = DAA_GERMANY;
8362 /*----------------------------------------------- */
8363 /* CAO */
8364 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8365 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8366 }
8367
8368 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8369 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8370 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8371 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8372 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8373 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8374 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8375 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8376 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8377 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8378 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8379 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8380 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8381 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8382 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8383 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8384 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8385 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8386 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8387 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8388 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8389 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8390 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8391 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8392 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8393 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8394 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8395 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8396 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8397 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8398 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8399 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8400 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8401 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8402 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8403 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8404 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8405 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8406 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8407 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8408 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8409 /* Bytes for AR-filter (09): 72,42,13,4B */
8410 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8411 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8412 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8413 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8414 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8415 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8416 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8417 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8418 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8419 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8420 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8421 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8422 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8423 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8424 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8425 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8426 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8427 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8428 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8429 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8430 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8431 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8432 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8433 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8434 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8435 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8436 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8437 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8438 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8439 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8440 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8441 /* ; (10K, 0.68uF) */
8442 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8443 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8444 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8445 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8446 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8447 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8448 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8449 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8450 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8451 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8452 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8453 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8454 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8455 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8456 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8457 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8458 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8459 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8460 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8461 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8462 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8463 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8464 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8465 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8466 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8467 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8468 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8469 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8470 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8471 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8472 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8473 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8474 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8475 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8476 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8477 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8478 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8479 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8480 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8481 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8482 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8483 /* ;CR Registers */
8484 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8485 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8486 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8487 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8488 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8489 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8490 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8491 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8492 /* Config. Reg. 4 (analog gain) (cr4):02 */
8493 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8494 /* Config. Reg. 5 (Version) (cr5):02 */
8495 /* Config. Reg. 6 (Reserved) (cr6):00 */
8496 /* Config. Reg. 7 (Reserved) (cr7):00 */
8497 /* ;xr Registers */
8498 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8499
8500 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8501 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8502
8503 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8504 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8505
8506 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8507 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8508 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8509 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8510 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8511 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8512 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8513 /* Ext. Reg. 6 (Power State) (xr6):00 */
8514 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8515 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8516 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8517 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8518 /* 12,33,5A,C3 ; 770 Hz */
8519 /* 13,3C,5B,32 ; 852 Hz */
8520 /* 1D,1B,5C,CC ; 941 Hz */
8521
8522 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8523 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8524 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8525 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8526 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8527 /* EC,1D,52,22 ; 1336 Hz */
8528 /* AA,AC,51,D2 ; 1477 Hz */
8529 /* 9B,3B,51,25 ; 1633 Hz */
8530 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8531 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8532 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8533 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8534 }
8535
8536
8537 static void DAA_Coeff_Australia(IXJ *j)
8538 {
8539 int i;
8540
8541 j->daa_country = DAA_AUSTRALIA;
8542 /*----------------------------------------------- */
8543 /* CAO */
8544 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8545 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8546 }
8547
8548 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8549 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8550 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8551 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8552 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8553 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8554 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8555 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8556 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8557 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8558 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8559 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8560 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8561 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8562 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8563 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8564 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8565 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8566 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8567 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8568 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8569 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8570 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8571 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8572 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8573 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8574 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8575 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8576 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8577 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8578 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8579 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8580 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8581 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8582 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8583 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8584 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8585 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8586 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8587 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8588 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8589 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8590 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8591 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8592 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8593 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8594 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8595 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8596 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8597 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8598 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8599 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8600 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8601 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8602 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8603 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8604 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8605 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8606 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8607 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8608 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8609 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8610 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8611 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8612 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8613 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8614 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8615 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8616 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8617 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8618 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8619 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8620 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8621 /* ; idle */
8622 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8623 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8624 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8625 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8626 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8627 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8628 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8629 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8630 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8631 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8632 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8633 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8634 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8635 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8636 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8637 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8638 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8639 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8640 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8641 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8642 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8643 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8644 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8645 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8646 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8647 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8648 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8649 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8650 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8651 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8652 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8653 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8654 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8655 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8656 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8657 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8658 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8659 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8660 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8661 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8662 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8663 /* ;CR Registers */
8664 /* Config. Reg. 0 (filters) (cr0):FF */
8665 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8666 /* Config. Reg. 1 (dialing) (cr1):05 */
8667 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8668 /* Config. Reg. 2 (caller ID) (cr2):04 */
8669 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8670 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8671 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8672 /* Config. Reg. 4 (analog gain) (cr4):02 */
8673 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8674 /* Config. Reg. 5 (Version) (cr5):02 */
8675 /* Config. Reg. 6 (Reserved) (cr6):00 */
8676 /* Config. Reg. 7 (Reserved) (cr7):00 */
8677 /* ;xr Registers */
8678 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8679
8680 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8681 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8682
8683 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8684 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8685
8686 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8687 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8688 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8689 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8690 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8691 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8692 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8693 /* Ext. Reg. 6 (Power State) (xr6):00 */
8694 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8695 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8696 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8697
8698 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8699 /* 12,33,5A,C3 ; 770 Hz */
8700 /* 13,3C,5B,32 ; 852 Hz */
8701 /* 1D,1B,5C,CC ; 941 Hz */
8702 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8703 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8704 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8705 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8706
8707 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8708 /* EC,1D,52,22 ; 1336 Hz */
8709 /* AA,AC,51,D2 ; 1477 Hz */
8710 /* 9B,3B,51,25 ; 1633 Hz */
8711 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8712 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8713 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8714 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8715 }
8716
8717 static void DAA_Coeff_Japan(IXJ *j)
8718 {
8719 int i;
8720
8721 j->daa_country = DAA_JAPAN;
8722 /*----------------------------------------------- */
8723 /* CAO */
8724 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8725 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8726 }
8727
8728 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8729 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8730 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8731 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8732 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8733 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8734 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8735 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8736 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8737 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8738 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8739 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8740 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8741 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8742 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8743 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8744 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8745 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8746 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8747 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8748 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8749 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8750 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8751 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8752 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8753 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8754 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8755 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8756 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8757 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8758 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8759 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8760 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8761 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8762 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8763 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8764 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8765 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8766 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8767 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8768 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8769 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8770 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8771 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8772 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8773 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8774 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8775 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8776 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8777 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8778 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8779 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8780 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8781 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8782 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8783 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8784 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8785 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8786 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8787 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8788 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8789 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8790 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8791 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8792 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8793 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8794 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8795 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8796 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8797 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8798 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8799 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8800 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8801 /* ; idle */
8802 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8803 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8804 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8805 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8806 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8807 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8808 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8809 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8810 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8811 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8812 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8813 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8814 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8815 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8816 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8817 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8818 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8819 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8820 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8821 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8822 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8823 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8824 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8825 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8826 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8827 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8828 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8829 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8830 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8831 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8832 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8833 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8834 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8835 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8836 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8837 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8838 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8839 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8840 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8841 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8842 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8843 /* ;CR Registers */
8844 /* Config. Reg. 0 (filters) (cr0):FF */
8845 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8846 /* Config. Reg. 1 (dialing) (cr1):05 */
8847 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8848 /* Config. Reg. 2 (caller ID) (cr2):04 */
8849 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8850 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8851 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8852 /* Config. Reg. 4 (analog gain) (cr4):02 */
8853 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8854 /* Config. Reg. 5 (Version) (cr5):02 */
8855 /* Config. Reg. 6 (Reserved) (cr6):00 */
8856 /* Config. Reg. 7 (Reserved) (cr7):00 */
8857 /* ;xr Registers */
8858 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8859
8860 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8861 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8862
8863 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8864 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8865
8866 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8867 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8868 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8869 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8870 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8871 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8872 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8873 /* Ext. Reg. 6 (Power State) (xr6):00 */
8874 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8875 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8876 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8877 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8878 /* 12,33,5A,C3 ; 770 Hz */
8879 /* 13,3C,5B,32 ; 852 Hz */
8880 /* 1D,1B,5C,CC ; 941 Hz */
8881
8882 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8883 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8884 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8885 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8886 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8887 /* EC,1D,52,22 ; 1336 Hz */
8888 /* AA,AC,51,D2 ; 1477 Hz */
8889 /* 9B,3B,51,25 ; 1633 Hz */
8890 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8891 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8892 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8893 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8894 }
8895
8896 static s16 tone_table[][19] =
8897 {
8898 { /* f20_50[] 11 */
8899 32538, /* A1 = 1.985962 */
8900 -32325, /* A2 = -0.986511 */
8901 -343, /* B2 = -0.010493 */
8902 0, /* B1 = 0 */
8903 343, /* B0 = 0.010493 */
8904 32619, /* A1 = 1.990906 */
8905 -32520, /* A2 = -0.992462 */
8906 19179, /* B2 = 0.585327 */
8907 -19178, /* B1 = -1.170593 */
8908 19179, /* B0 = 0.585327 */
8909 32723, /* A1 = 1.997314 */
8910 -32686, /* A2 = -0.997528 */
8911 9973, /* B2 = 0.304352 */
8912 -9955, /* B1 = -0.607605 */
8913 9973, /* B0 = 0.304352 */
8914 7, /* Internal filter scaling */
8915 159, /* Minimum in-band energy threshold */
8916 21, /* 21/32 in-band to broad-band ratio */
8917 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8918 },
8919 { /* f133_200[] 12 */
8920 32072, /* A1 = 1.95752 */
8921 -31896, /* A2 = -0.973419 */
8922 -435, /* B2 = -0.013294 */
8923 0, /* B1 = 0 */
8924 435, /* B0 = 0.013294 */
8925 32188, /* A1 = 1.9646 */
8926 -32400, /* A2 = -0.98877 */
8927 15139, /* B2 = 0.462036 */
8928 -14882, /* B1 = -0.908356 */
8929 15139, /* B0 = 0.462036 */
8930 32473, /* A1 = 1.981995 */
8931 -32524, /* A2 = -0.992584 */
8932 23200, /* B2 = 0.708008 */
8933 -23113, /* B1 = -1.410706 */
8934 23200, /* B0 = 0.708008 */
8935 7, /* Internal filter scaling */
8936 159, /* Minimum in-band energy threshold */
8937 21, /* 21/32 in-band to broad-band ratio */
8938 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8939 },
8940 { /* f300 13 */
8941 31769, /* A1 = -1.939026 */
8942 -32584, /* A2 = 0.994385 */
8943 -475, /* B2 = -0.014522 */
8944 0, /* B1 = 0.000000 */
8945 475, /* B0 = 0.014522 */
8946 31789, /* A1 = -1.940247 */
8947 -32679, /* A2 = 0.997284 */
8948 17280, /* B2 = 0.527344 */
8949 -16865, /* B1 = -1.029358 */
8950 17280, /* B0 = 0.527344 */
8951 31841, /* A1 = -1.943481 */
8952 -32681, /* A2 = 0.997345 */
8953 543, /* B2 = 0.016579 */
8954 -525, /* B1 = -0.032097 */
8955 543, /* B0 = 0.016579 */
8956 5, /* Internal filter scaling */
8957 159, /* Minimum in-band energy threshold */
8958 21, /* 21/32 in-band to broad-band ratio */
8959 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8960 },
8961 { /* f300_420[] 14 */
8962 30750, /* A1 = 1.876892 */
8963 -31212, /* A2 = -0.952515 */
8964 -804, /* B2 = -0.024541 */
8965 0, /* B1 = 0 */
8966 804, /* B0 = 0.024541 */
8967 30686, /* A1 = 1.872925 */
8968 -32145, /* A2 = -0.980988 */
8969 14747, /* B2 = 0.450043 */
8970 -13703, /* B1 = -0.836395 */
8971 14747, /* B0 = 0.450043 */
8972 31651, /* A1 = 1.931824 */
8973 -32321, /* A2 = -0.986389 */
8974 24425, /* B2 = 0.745422 */
8975 -23914, /* B1 = -1.459595 */
8976 24427, /* B0 = 0.745483 */
8977 7, /* Internal filter scaling */
8978 159, /* Minimum in-band energy threshold */
8979 21, /* 21/32 in-band to broad-band ratio */
8980 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8981 },
8982 { /* f330 15 */
8983 31613, /* A1 = -1.929565 */
8984 -32646, /* A2 = 0.996277 */
8985 -185, /* B2 = -0.005657 */
8986 0, /* B1 = 0.000000 */
8987 185, /* B0 = 0.005657 */
8988 31620, /* A1 = -1.929932 */
8989 -32713, /* A2 = 0.998352 */
8990 19253, /* B2 = 0.587585 */
8991 -18566, /* B1 = -1.133179 */
8992 19253, /* B0 = 0.587585 */
8993 31674, /* A1 = -1.933228 */
8994 -32715, /* A2 = 0.998413 */
8995 2575, /* B2 = 0.078590 */
8996 -2495, /* B1 = -0.152283 */
8997 2575, /* B0 = 0.078590 */
8998 5, /* Internal filter scaling */
8999 159, /* Minimum in-band energy threshold */
9000 21, /* 21/32 in-band to broad-band ratio */
9001 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9002 },
9003 { /* f300_425[] 16 */
9004 30741, /* A1 = 1.876282 */
9005 -31475, /* A2 = -0.960541 */
9006 -703, /* B2 = -0.021484 */
9007 0, /* B1 = 0 */
9008 703, /* B0 = 0.021484 */
9009 30688, /* A1 = 1.873047 */
9010 -32248, /* A2 = -0.984161 */
9011 14542, /* B2 = 0.443787 */
9012 -13523, /* B1 = -0.825439 */
9013 14542, /* B0 = 0.443817 */
9014 31494, /* A1 = 1.922302 */
9015 -32366, /* A2 = -0.987762 */
9016 21577, /* B2 = 0.658508 */
9017 -21013, /* B1 = -1.282532 */
9018 21577, /* B0 = 0.658508 */
9019 7, /* Internal filter scaling */
9020 159, /* Minimum in-band energy threshold */
9021 21, /* 21/32 in-band to broad-band ratio */
9022 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9023 },
9024 { /* f330_440[] 17 */
9025 30627, /* A1 = 1.869324 */
9026 -31338, /* A2 = -0.95636 */
9027 -843, /* B2 = -0.025749 */
9028 0, /* B1 = 0 */
9029 843, /* B0 = 0.025749 */
9030 30550, /* A1 = 1.864685 */
9031 -32221, /* A2 = -0.983337 */
9032 13594, /* B2 = 0.414886 */
9033 -12589, /* B1 = -0.768402 */
9034 13594, /* B0 = 0.414886 */
9035 31488, /* A1 = 1.921936 */
9036 -32358, /* A2 = -0.987518 */
9037 24684, /* B2 = 0.753296 */
9038 -24029, /* B1 = -1.466614 */
9039 24684, /* B0 = 0.753296 */
9040 7, /* Internal filter scaling */
9041 159, /* Minimum in-band energy threshold */
9042 21, /* 21/32 in-band to broad-band ratio */
9043 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9044 },
9045 { /* f340 18 */
9046 31546, /* A1 = -1.925476 */
9047 -32646, /* A2 = 0.996277 */
9048 -445, /* B2 = -0.013588 */
9049 0, /* B1 = 0.000000 */
9050 445, /* B0 = 0.013588 */
9051 31551, /* A1 = -1.925781 */
9052 -32713, /* A2 = 0.998352 */
9053 23884, /* B2 = 0.728882 */
9054 -22979, /* B1 = -1.402527 */
9055 23884, /* B0 = 0.728882 */
9056 31606, /* A1 = -1.929138 */
9057 -32715, /* A2 = 0.998413 */
9058 863, /* B2 = 0.026367 */
9059 -835, /* B1 = -0.050985 */
9060 863, /* B0 = 0.026367 */
9061 5, /* Internal filter scaling */
9062 159, /* Minimum in-band energy threshold */
9063 21, /* 21/32 in-band to broad-band ratio */
9064 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9065 },
9066 { /* f350_400[] 19 */
9067 31006, /* A1 = 1.892517 */
9068 -32029, /* A2 = -0.977448 */
9069 -461, /* B2 = -0.014096 */
9070 0, /* B1 = 0 */
9071 461, /* B0 = 0.014096 */
9072 30999, /* A1 = 1.892029 */
9073 -32487, /* A2 = -0.991455 */
9074 11325, /* B2 = 0.345612 */
9075 -10682, /* B1 = -0.651978 */
9076 11325, /* B0 = 0.345612 */
9077 31441, /* A1 = 1.919067 */
9078 -32526, /* A2 = -0.992615 */
9079 24324, /* B2 = 0.74231 */
9080 -23535, /* B1 = -1.436523 */
9081 24324, /* B0 = 0.74231 */
9082 7, /* Internal filter scaling */
9083 159, /* Minimum in-band energy threshold */
9084 21, /* 21/32 in-band to broad-band ratio */
9085 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9086 },
9087 { /* f350_440[] */
9088 30634, /* A1 = 1.869751 */
9089 -31533, /* A2 = -0.962341 */
9090 -680, /* B2 = -0.020782 */
9091 0, /* B1 = 0 */
9092 680, /* B0 = 0.020782 */
9093 30571, /* A1 = 1.865906 */
9094 -32277, /* A2 = -0.985016 */
9095 12894, /* B2 = 0.393524 */
9096 -11945, /* B1 = -0.729065 */
9097 12894, /* B0 = 0.393524 */
9098 31367, /* A1 = 1.91449 */
9099 -32379, /* A2 = -0.988129 */
9100 23820, /* B2 = 0.726929 */
9101 -23104, /* B1 = -1.410217 */
9102 23820, /* B0 = 0.726929 */
9103 7, /* Internal filter scaling */
9104 159, /* Minimum in-band energy threshold */
9105 21, /* 21/32 in-band to broad-band ratio */
9106 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9107 },
9108 { /* f350_450[] */
9109 30552, /* A1 = 1.864807 */
9110 -31434, /* A2 = -0.95929 */
9111 -690, /* B2 = -0.021066 */
9112 0, /* B1 = 0 */
9113 690, /* B0 = 0.021066 */
9114 30472, /* A1 = 1.859924 */
9115 -32248, /* A2 = -0.984161 */
9116 13385, /* B2 = 0.408478 */
9117 -12357, /* B1 = -0.754242 */
9118 13385, /* B0 = 0.408478 */
9119 31358, /* A1 = 1.914001 */
9120 -32366, /* A2 = -0.987732 */
9121 26488, /* B2 = 0.80835 */
9122 -25692, /* B1 = -1.568176 */
9123 26490, /* B0 = 0.808411 */
9124 7, /* Internal filter scaling */
9125 159, /* Minimum in-band energy threshold */
9126 21, /* 21/32 in-band to broad-band ratio */
9127 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9128 },
9129 { /* f360 */
9130 31397, /* A1 = -1.916321 */
9131 -32623, /* A2 = 0.995605 */
9132 -117, /* B2 = -0.003598 */
9133 0, /* B1 = 0.000000 */
9134 117, /* B0 = 0.003598 */
9135 31403, /* A1 = -1.916687 */
9136 -32700, /* A2 = 0.997925 */
9137 3388, /* B2 = 0.103401 */
9138 -3240, /* B1 = -0.197784 */
9139 3388, /* B0 = 0.103401 */
9140 31463, /* A1 = -1.920410 */
9141 -32702, /* A2 = 0.997986 */
9142 13346, /* B2 = 0.407288 */
9143 -12863, /* B1 = -0.785126 */
9144 13346, /* B0 = 0.407288 */
9145 5, /* Internal filter scaling */
9146 159, /* Minimum in-band energy threshold */
9147 21, /* 21/32 in-band to broad-band ratio */
9148 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9149 },
9150 { /* f380_420[] */
9151 30831, /* A1 = 1.881775 */
9152 -32064, /* A2 = -0.978546 */
9153 -367, /* B2 = -0.01122 */
9154 0, /* B1 = 0 */
9155 367, /* B0 = 0.01122 */
9156 30813, /* A1 = 1.880737 */
9157 -32456, /* A2 = -0.990509 */
9158 11068, /* B2 = 0.337769 */
9159 -10338, /* B1 = -0.631042 */
9160 11068, /* B0 = 0.337769 */
9161 31214, /* A1 = 1.905212 */
9162 -32491, /* A2 = -0.991577 */
9163 16374, /* B2 = 0.499695 */
9164 -15781, /* B1 = -0.963196 */
9165 16374, /* B0 = 0.499695 */
9166 7, /* Internal filter scaling */
9167 159, /* Minimum in-band energy threshold */
9168 21, /* 21/32 in-band to broad-band ratio */
9169 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9170 },
9171 { /* f392 */
9172 31152, /* A1 = -1.901428 */
9173 -32613, /* A2 = 0.995300 */
9174 -314, /* B2 = -0.009605 */
9175 0, /* B1 = 0.000000 */
9176 314, /* B0 = 0.009605 */
9177 31156, /* A1 = -1.901672 */
9178 -32694, /* A2 = 0.997742 */
9179 28847, /* B2 = 0.880371 */
9180 -2734, /* B1 = -0.166901 */
9181 28847, /* B0 = 0.880371 */
9182 31225, /* A1 = -1.905823 */
9183 -32696, /* A2 = 0.997803 */
9184 462, /* B2 = 0.014108 */
9185 -442, /* B1 = -0.027019 */
9186 462, /* B0 = 0.014108 */
9187 5, /* Internal filter scaling */
9188 159, /* Minimum in-band energy threshold */
9189 21, /* 21/32 in-band to broad-band ratio */
9190 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9191 },
9192 { /* f400_425[] */
9193 30836, /* A1 = 1.882141 */
9194 -32296, /* A2 = -0.985596 */
9195 -324, /* B2 = -0.009903 */
9196 0, /* B1 = 0 */
9197 324, /* B0 = 0.009903 */
9198 30825, /* A1 = 1.881409 */
9199 -32570, /* A2 = -0.993958 */
9200 16847, /* B2 = 0.51416 */
9201 -15792, /* B1 = -0.963898 */
9202 16847, /* B0 = 0.51416 */
9203 31106, /* A1 = 1.89856 */
9204 -32584, /* A2 = -0.994415 */
9205 9579, /* B2 = 0.292328 */
9206 -9164, /* B1 = -0.559357 */
9207 9579, /* B0 = 0.292328 */
9208 7, /* Internal filter scaling */
9209 159, /* Minimum in-band energy threshold */
9210 21, /* 21/32 in-band to broad-band ratio */
9211 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9212 },
9213 { /* f400_440[] */
9214 30702, /* A1 = 1.873962 */
9215 -32134, /* A2 = -0.980682 */
9216 -517, /* B2 = -0.015793 */
9217 0, /* B1 = 0 */
9218 517, /* B0 = 0.015793 */
9219 30676, /* A1 = 1.872375 */
9220 -32520, /* A2 = -0.992462 */
9221 8144, /* B2 = 0.24855 */
9222 -7596, /* B1 = -0.463684 */
9223 8144, /* B0 = 0.24855 */
9224 31084, /* A1 = 1.897217 */
9225 -32547, /* A2 = -0.993256 */
9226 22713, /* B2 = 0.693176 */
9227 -21734, /* B1 = -1.326599 */
9228 22713, /* B0 = 0.693176 */
9229 7, /* Internal filter scaling */
9230 159, /* Minimum in-band energy threshold */
9231 21, /* 21/32 in-band to broad-band ratio */
9232 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9233 },
9234 { /* f400_450[] */
9235 30613, /* A1 = 1.86853 */
9236 -32031, /* A2 = -0.977509 */
9237 -618, /* B2 = -0.018866 */
9238 0, /* B1 = 0 */
9239 618, /* B0 = 0.018866 */
9240 30577, /* A1 = 1.866272 */
9241 -32491, /* A2 = -0.991577 */
9242 9612, /* B2 = 0.293335 */
9243 -8935, /* B1 = -0.54541 */
9244 9612, /* B0 = 0.293335 */
9245 31071, /* A1 = 1.896484 */
9246 -32524, /* A2 = -0.992584 */
9247 21596, /* B2 = 0.659058 */
9248 -20667, /* B1 = -1.261414 */
9249 21596, /* B0 = 0.659058 */
9250 7, /* Internal filter scaling */
9251 159, /* Minimum in-band energy threshold */
9252 21, /* 21/32 in-band to broad-band ratio */
9253 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9254 },
9255 { /* f420 */
9256 30914, /* A1 = -1.886841 */
9257 -32584, /* A2 = 0.994385 */
9258 -426, /* B2 = -0.013020 */
9259 0, /* B1 = 0.000000 */
9260 426, /* B0 = 0.013020 */
9261 30914, /* A1 = -1.886841 */
9262 -32679, /* A2 = 0.997314 */
9263 17520, /* B2 = 0.534668 */
9264 -16471, /* B1 = -1.005310 */
9265 17520, /* B0 = 0.534668 */
9266 31004, /* A1 = -1.892334 */
9267 -32683, /* A2 = 0.997406 */
9268 819, /* B2 = 0.025023 */
9269 -780, /* B1 = -0.047619 */
9270 819, /* B0 = 0.025023 */
9271 5, /* Internal filter scaling */
9272 159, /* Minimum in-band energy threshold */
9273 21, /* 21/32 in-band to broad-band ratio */
9274 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9275 },
9276 #if 0
9277 { /* f425 */
9278 30881, /* A1 = -1.884827 */
9279 -32603, /* A2 = 0.994965 */
9280 -496, /* B2 = -0.015144 */
9281 0, /* B1 = 0.000000 */
9282 496, /* B0 = 0.015144 */
9283 30880, /* A1 = -1.884766 */
9284 -32692, /* A2 = 0.997711 */
9285 24767, /* B2 = 0.755859 */
9286 -23290, /* B1 = -1.421509 */
9287 24767, /* B0 = 0.755859 */
9288 30967, /* A1 = -1.890076 */
9289 -32694, /* A2 = 0.997772 */
9290 728, /* B2 = 0.022232 */
9291 -691, /* B1 = -0.042194 */
9292 728, /* B0 = 0.022232 */
9293 5, /* Internal filter scaling */
9294 159, /* Minimum in-band energy threshold */
9295 21, /* 21/32 in-band to broad-band ratio */
9296 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9297 },
9298 #else
9299 {
9300 30850,
9301 -32534,
9302 -504,
9303 0,
9304 504,
9305 30831,
9306 -32669,
9307 24303,
9308 -22080,
9309 24303,
9310 30994,
9311 -32673,
9312 1905,
9313 -1811,
9314 1905,
9315 5,
9316 129,
9317 17,
9318 0xff5
9319 },
9320 #endif
9321 { /* f425_450[] */
9322 30646, /* A1 = 1.870544 */
9323 -32327, /* A2 = -0.986572 */
9324 -287, /* B2 = -0.008769 */
9325 0, /* B1 = 0 */
9326 287, /* B0 = 0.008769 */
9327 30627, /* A1 = 1.869324 */
9328 -32607, /* A2 = -0.995087 */
9329 13269, /* B2 = 0.404968 */
9330 -12376, /* B1 = -0.755432 */
9331 13269, /* B0 = 0.404968 */
9332 30924, /* A1 = 1.887512 */
9333 -32619, /* A2 = -0.995453 */
9334 19950, /* B2 = 0.608826 */
9335 -18940, /* B1 = -1.156006 */
9336 19950, /* B0 = 0.608826 */
9337 7, /* Internal filter scaling */
9338 159, /* Minimum in-band energy threshold */
9339 21, /* 21/32 in-band to broad-band ratio */
9340 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9341 },
9342 { /* f425_475[] */
9343 30396, /* A1 = 1.855225 */
9344 -32014, /* A2 = -0.97699 */
9345 -395, /* B2 = -0.012055 */
9346 0, /* B1 = 0 */
9347 395, /* B0 = 0.012055 */
9348 30343, /* A1 = 1.85199 */
9349 -32482, /* A2 = -0.991302 */
9350 17823, /* B2 = 0.543945 */
9351 -16431, /* B1 = -1.002869 */
9352 17823, /* B0 = 0.543945 */
9353 30872, /* A1 = 1.884338 */
9354 -32516, /* A2 = -0.99231 */
9355 18124, /* B2 = 0.553101 */
9356 -17246, /* B1 = -1.052673 */
9357 18124, /* B0 = 0.553101 */
9358 7, /* Internal filter scaling */
9359 159, /* Minimum in-band energy threshold */
9360 21, /* 21/32 in-band to broad-band ratio */
9361 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9362 },
9363 { /* f435 */
9364 30796, /* A1 = -1.879639 */
9365 -32603, /* A2 = 0.994965 */
9366 -254, /* B2 = -0.007762 */
9367 0, /* B1 = 0.000000 */
9368 254, /* B0 = 0.007762 */
9369 30793, /* A1 = -1.879456 */
9370 -32692, /* A2 = 0.997711 */
9371 18934, /* B2 = 0.577820 */
9372 -17751, /* B1 = -1.083496 */
9373 18934, /* B0 = 0.577820 */
9374 30882, /* A1 = -1.884888 */
9375 -32694, /* A2 = 0.997772 */
9376 1858, /* B2 = 0.056713 */
9377 -1758, /* B1 = -0.107357 */
9378 1858, /* B0 = 0.056713 */
9379 5, /* Internal filter scaling */
9380 159, /* Minimum in-band energy threshold */
9381 21, /* 21/32 in-band to broad-band ratio */
9382 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9383 },
9384 { /* f440_450[] */
9385 30641, /* A1 = 1.870239 */
9386 -32458, /* A2 = -0.99057 */
9387 -155, /* B2 = -0.004735 */
9388 0, /* B1 = 0 */
9389 155, /* B0 = 0.004735 */
9390 30631, /* A1 = 1.869568 */
9391 -32630, /* A2 = -0.995789 */
9392 11453, /* B2 = 0.349548 */
9393 -10666, /* B1 = -0.651001 */
9394 11453, /* B0 = 0.349548 */
9395 30810, /* A1 = 1.880554 */
9396 -32634, /* A2 = -0.995941 */
9397 12237, /* B2 = 0.373474 */
9398 -11588, /* B1 = -0.707336 */
9399 12237, /* B0 = 0.373474 */
9400 7, /* Internal filter scaling */
9401 159, /* Minimum in-band energy threshold */
9402 21, /* 21/32 in-band to broad-band ratio */
9403 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9404 },
9405 { /* f440_480[] */
9406 30367, /* A1 = 1.853455 */
9407 -32147, /* A2 = -0.981079 */
9408 -495, /* B2 = -0.015113 */
9409 0, /* B1 = 0 */
9410 495, /* B0 = 0.015113 */
9411 30322, /* A1 = 1.850769 */
9412 -32543, /* A2 = -0.993134 */
9413 10031, /* B2 = 0.306152 */
9414 -9252, /* B1 = -0.564728 */
9415 10031, /* B0 = 0.306152 */
9416 30770, /* A1 = 1.878052 */
9417 -32563, /* A2 = -0.993774 */
9418 22674, /* B2 = 0.691956 */
9419 -21465, /* B1 = -1.31012 */
9420 22674, /* B0 = 0.691956 */
9421 7, /* Internal filter scaling */
9422 159, /* Minimum in-band energy threshold */
9423 21, /* 21/32 in-band to broad-band ratio */
9424 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9425 },
9426 { /* f445 */
9427 30709, /* A1 = -1.874329 */
9428 -32603, /* A2 = 0.994965 */
9429 -83, /* B2 = -0.002545 */
9430 0, /* B1 = 0.000000 */
9431 83, /* B0 = 0.002545 */
9432 30704, /* A1 = -1.874084 */
9433 -32692, /* A2 = 0.997711 */
9434 10641, /* B2 = 0.324738 */
9435 -9947, /* B1 = -0.607147 */
9436 10641, /* B0 = 0.324738 */
9437 30796, /* A1 = -1.879639 */
9438 -32694, /* A2 = 0.997772 */
9439 10079, /* B2 = 0.307587 */
9440 9513, /* B1 = 0.580688 */
9441 10079, /* B0 = 0.307587 */
9442 5, /* Internal filter scaling */
9443 159, /* Minimum in-band energy threshold */
9444 21, /* 21/32 in-band to broad-band ratio */
9445 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9446 },
9447 { /* f450 */
9448 30664, /* A1 = -1.871643 */
9449 -32603, /* A2 = 0.994965 */
9450 -164, /* B2 = -0.005029 */
9451 0, /* B1 = 0.000000 */
9452 164, /* B0 = 0.005029 */
9453 30661, /* A1 = -1.871399 */
9454 -32692, /* A2 = 0.997711 */
9455 15294, /* B2 = 0.466736 */
9456 -14275, /* B1 = -0.871307 */
9457 15294, /* B0 = 0.466736 */
9458 30751, /* A1 = -1.876953 */
9459 -32694, /* A2 = 0.997772 */
9460 3548, /* B2 = 0.108284 */
9461 -3344, /* B1 = -0.204155 */
9462 3548, /* B0 = 0.108284 */
9463 5, /* Internal filter scaling */
9464 159, /* Minimum in-band energy threshold */
9465 21, /* 21/32 in-band to broad-band ratio */
9466 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9467 },
9468 { /* f452 */
9469 30653, /* A1 = -1.870911 */
9470 -32615, /* A2 = 0.995361 */
9471 -209, /* B2 = -0.006382 */
9472 0, /* B1 = 0.000000 */
9473 209, /* B0 = 0.006382 */
9474 30647, /* A1 = -1.870605 */
9475 -32702, /* A2 = 0.997986 */
9476 18971, /* B2 = 0.578979 */
9477 -17716, /* B1 = -1.081299 */
9478 18971, /* B0 = 0.578979 */
9479 30738, /* A1 = -1.876099 */
9480 -32702, /* A2 = 0.998016 */
9481 2967, /* B2 = 0.090561 */
9482 -2793, /* B1 = -0.170502 */
9483 2967, /* B0 = 0.090561 */
9484 5, /* Internal filter scaling */
9485 159, /* Minimum in-band energy threshold */
9486 21, /* 21/32 in-band to broad-band ratio */
9487 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9488 },
9489 { /* f475 */
9490 30437, /* A1 = -1.857727 */
9491 -32603, /* A2 = 0.994965 */
9492 -264, /* B2 = -0.008062 */
9493 0, /* B1 = 0.000000 */
9494 264, /* B0 = 0.008062 */
9495 30430, /* A1 = -1.857300 */
9496 -32692, /* A2 = 0.997711 */
9497 21681, /* B2 = 0.661682 */
9498 -20082, /* B1 = -1.225708 */
9499 21681, /* B0 = 0.661682 */
9500 30526, /* A1 = -1.863220 */
9501 -32694, /* A2 = 0.997742 */
9502 1559, /* B2 = 0.047600 */
9503 -1459, /* B1 = -0.089096 */
9504 1559, /* B0 = 0.047600 */
9505 5, /* Internal filter scaling */
9506 159, /* Minimum in-band energy threshold */
9507 21, /* 21/32 in-band to broad-band ratio */
9508 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9509 },
9510 { /* f480_620[] */
9511 28975, /* A1 = 1.768494 */
9512 -30955, /* A2 = -0.944672 */
9513 -1026, /* B2 = -0.03133 */
9514 0, /* B1 = 0 */
9515 1026, /* B0 = 0.03133 */
9516 28613, /* A1 = 1.746399 */
9517 -32089, /* A2 = -0.979309 */
9518 14214, /* B2 = 0.433807 */
9519 -12202, /* B1 = -0.744812 */
9520 14214, /* B0 = 0.433807 */
9521 30243, /* A1 = 1.845947 */
9522 -32238, /* A2 = -0.983856 */
9523 24825, /* B2 = 0.757629 */
9524 -23402, /* B1 = -1.428345 */
9525 24825, /* B0 = 0.757629 */
9526 7, /* Internal filter scaling */
9527 159, /* Minimum in-band energy threshold */
9528 21, /* 21/32 in-band to broad-band ratio */
9529 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9530 },
9531 { /* f494 */
9532 30257, /* A1 = -1.846741 */
9533 -32605, /* A2 = 0.995056 */
9534 -249, /* B2 = -0.007625 */
9535 0, /* B1 = 0.000000 */
9536 249, /* B0 = 0.007625 */
9537 30247, /* A1 = -1.846191 */
9538 -32694, /* A2 = 0.997772 */
9539 18088, /* B2 = 0.552002 */
9540 -16652, /* B1 = -1.016418 */
9541 18088, /* B0 = 0.552002 */
9542 30348, /* A1 = -1.852295 */
9543 -32696, /* A2 = 0.997803 */
9544 2099, /* B2 = 0.064064 */
9545 -1953, /* B1 = -0.119202 */
9546 2099, /* B0 = 0.064064 */
9547 5, /* Internal filter scaling */
9548 159, /* Minimum in-band energy threshold */
9549 21, /* 21/32 in-band to broad-band ratio */
9550 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9551 },
9552 { /* f500 */
9553 30202, /* A1 = -1.843431 */
9554 -32624, /* A2 = 0.995622 */
9555 -413, /* B2 = -0.012622 */
9556 0, /* B1 = 0.000000 */
9557 413, /* B0 = 0.012622 */
9558 30191, /* A1 = -1.842721 */
9559 -32714, /* A2 = 0.998364 */
9560 25954, /* B2 = 0.792057 */
9561 -23890, /* B1 = -1.458131 */
9562 25954, /* B0 = 0.792057 */
9563 30296, /* A1 = -1.849172 */
9564 -32715, /* A2 = 0.998397 */
9565 2007, /* B2 = 0.061264 */
9566 -1860, /* B1 = -0.113568 */
9567 2007, /* B0 = 0.061264 */
9568 5, /* Internal filter scaling */
9569 159, /* Minimum in-band energy threshold */
9570 21, /* 21/32 in-band to broad-band ratio */
9571 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9572 },
9573 { /* f520 */
9574 30001, /* A1 = -1.831116 */
9575 -32613, /* A2 = 0.995270 */
9576 -155, /* B2 = -0.004750 */
9577 0, /* B1 = 0.000000 */
9578 155, /* B0 = 0.004750 */
9579 29985, /* A1 = -1.830200 */
9580 -32710, /* A2 = 0.998260 */
9581 6584, /* B2 = 0.200928 */
9582 -6018, /* B1 = -0.367355 */
9583 6584, /* B0 = 0.200928 */
9584 30105, /* A1 = -1.837524 */
9585 -32712, /* A2 = 0.998291 */
9586 23812, /* B2 = 0.726685 */
9587 -21936, /* B1 = -1.338928 */
9588 23812, /* B0 = 0.726685 */
9589 5, /* Internal filter scaling */
9590 159, /* Minimum in-band energy threshold */
9591 21, /* 21/32 in-band to broad-band ratio */
9592 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9593 },
9594 { /* f523 */
9595 29964, /* A1 = -1.828918 */
9596 -32601, /* A2 = 0.994904 */
9597 -101, /* B2 = -0.003110 */
9598 0, /* B1 = 0.000000 */
9599 101, /* B0 = 0.003110 */
9600 29949, /* A1 = -1.827942 */
9601 -32700, /* A2 = 0.997925 */
9602 11041, /* B2 = 0.336975 */
9603 -10075, /* B1 = -0.614960 */
9604 11041, /* B0 = 0.336975 */
9605 30070, /* A1 = -1.835388 */
9606 -32702, /* A2 = 0.997986 */
9607 16762, /* B2 = 0.511536 */
9608 -15437, /* B1 = -0.942230 */
9609 16762, /* B0 = 0.511536 */
9610 5, /* Internal filter scaling */
9611 159, /* Minimum in-band energy threshold */
9612 21, /* 21/32 in-band to broad-band ratio */
9613 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9614 },
9615 { /* f525 */
9616 29936, /* A1 = -1.827209 */
9617 -32584, /* A2 = 0.994415 */
9618 -91, /* B2 = -0.002806 */
9619 0, /* B1 = 0.000000 */
9620 91, /* B0 = 0.002806 */
9621 29921, /* A1 = -1.826233 */
9622 -32688, /* A2 = 0.997559 */
9623 11449, /* B2 = 0.349396 */
9624 -10426, /* B1 = -0.636383 */
9625 11449, /* B0 = 0.349396 */
9626 30045, /* A1 = -1.833862 */
9627 -32688, /* A2 = 0.997589 */
9628 13055, /* B2 = 0.398407 */
9629 -12028, /* B1 = -0.734161 */
9630 13055, /* B0 = 0.398407 */
9631 5, /* Internal filter scaling */
9632 159, /* Minimum in-band energy threshold */
9633 21, /* 21/32 in-band to broad-band ratio */
9634 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9635 },
9636 { /* f540_660[] */
9637 28499, /* A1 = 1.739441 */
9638 -31129, /* A2 = -0.949982 */
9639 -849, /* B2 = -0.025922 */
9640 0, /* B1 = 0 */
9641 849, /* B0 = 0.025922 */
9642 28128, /* A1 = 1.716797 */
9643 -32130, /* A2 = -0.98056 */
9644 14556, /* B2 = 0.444214 */
9645 -12251, /* B1 = -0.747772 */
9646 14556, /* B0 = 0.444244 */
9647 29667, /* A1 = 1.81073 */
9648 -32244, /* A2 = -0.984039 */
9649 23038, /* B2 = 0.703064 */
9650 -21358, /* B1 = -1.303589 */
9651 23040, /* B0 = 0.703125 */
9652 7, /* Internal filter scaling */
9653 159, /* Minimum in-band energy threshold */
9654 21, /* 21/32 in-band to broad-band ratio */
9655 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9656 },
9657 { /* f587 */
9658 29271, /* A1 = -1.786560 */
9659 -32599, /* A2 = 0.994873 */
9660 -490, /* B2 = -0.014957 */
9661 0, /* B1 = 0.000000 */
9662 490, /* B0 = 0.014957 */
9663 29246, /* A1 = -1.785095 */
9664 -32700, /* A2 = 0.997925 */
9665 28961, /* B2 = 0.883850 */
9666 -25796, /* B1 = -1.574463 */
9667 28961, /* B0 = 0.883850 */
9668 29383, /* A1 = -1.793396 */
9669 -32700, /* A2 = 0.997955 */
9670 1299, /* B2 = 0.039650 */
9671 -1169, /* B1 = -0.071396 */
9672 1299, /* B0 = 0.039650 */
9673 5, /* Internal filter scaling */
9674 159, /* Minimum in-band energy threshold */
9675 21, /* 21/32 in-band to broad-band ratio */
9676 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9677 },
9678 { /* f590 */
9679 29230, /* A1 = -1.784058 */
9680 -32584, /* A2 = 0.994415 */
9681 -418, /* B2 = -0.012757 */
9682 0, /* B1 = 0.000000 */
9683 418, /* B0 = 0.012757 */
9684 29206, /* A1 = -1.782593 */
9685 -32688, /* A2 = 0.997559 */
9686 36556, /* B2 = 1.115601 */
9687 -32478, /* B1 = -1.982300 */
9688 36556, /* B0 = 1.115601 */
9689 29345, /* A1 = -1.791077 */
9690 -32688, /* A2 = 0.997589 */
9691 897, /* B2 = 0.027397 */
9692 -808, /* B1 = -0.049334 */
9693 897, /* B0 = 0.027397 */
9694 5, /* Internal filter scaling */
9695 159, /* Minimum in-band energy threshold */
9696 21, /* 21/32 in-band to broad-band ratio */
9697 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9698 },
9699 { /* f600 */
9700 29116, /* A1 = -1.777100 */
9701 -32603, /* A2 = 0.994965 */
9702 -165, /* B2 = -0.005039 */
9703 0, /* B1 = 0.000000 */
9704 165, /* B0 = 0.005039 */
9705 29089, /* A1 = -1.775452 */
9706 -32708, /* A2 = 0.998199 */
9707 6963, /* B2 = 0.212494 */
9708 -6172, /* B1 = -0.376770 */
9709 6963, /* B0 = 0.212494 */
9710 29237, /* A1 = -1.784485 */
9711 -32710, /* A2 = 0.998230 */
9712 24197, /* B2 = 0.738464 */
9713 -21657, /* B1 = -1.321899 */
9714 24197, /* B0 = 0.738464 */
9715 5, /* Internal filter scaling */
9716 159, /* Minimum in-band energy threshold */
9717 21, /* 21/32 in-band to broad-band ratio */
9718 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9719 },
9720 { /* f660 */
9721 28376, /* A1 = -1.731934 */
9722 -32567, /* A2 = 0.993896 */
9723 -363, /* B2 = -0.011102 */
9724 0, /* B1 = 0.000000 */
9725 363, /* B0 = 0.011102 */
9726 28337, /* A1 = -1.729614 */
9727 -32683, /* A2 = 0.997434 */
9728 21766, /* B2 = 0.664246 */
9729 -18761, /* B1 = -1.145081 */
9730 21766, /* B0 = 0.664246 */
9731 28513, /* A1 = -1.740356 */
9732 -32686, /* A2 = 0.997498 */
9733 2509, /* B2 = 0.076584 */
9734 -2196, /* B1 = -0.134041 */
9735 2509, /* B0 = 0.076584 */
9736 5, /* Internal filter scaling */
9737 159, /* Minimum in-band energy threshold */
9738 21, /* 21/32 in-band to broad-band ratio */
9739 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9740 },
9741 { /* f700 */
9742 27844, /* A1 = -1.699463 */
9743 -32563, /* A2 = 0.993744 */
9744 -366, /* B2 = -0.011187 */
9745 0, /* B1 = 0.000000 */
9746 366, /* B0 = 0.011187 */
9747 27797, /* A1 = -1.696655 */
9748 -32686, /* A2 = 0.997498 */
9749 22748, /* B2 = 0.694214 */
9750 -19235, /* B1 = -1.174072 */
9751 22748, /* B0 = 0.694214 */
9752 27995, /* A1 = -1.708740 */
9753 -32688, /* A2 = 0.997559 */
9754 2964, /* B2 = 0.090477 */
9755 -2546, /* B1 = -0.155449 */
9756 2964, /* B0 = 0.090477 */
9757 5, /* Internal filter scaling */
9758 159, /* Minimum in-band energy threshold */
9759 21, /* 21/32 in-band to broad-band ratio */
9760 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9761 },
9762 { /* f740 */
9763 27297, /* A1 = -1.666077 */
9764 -32551, /* A2 = 0.993408 */
9765 -345, /* B2 = -0.010540 */
9766 0, /* B1 = 0.000000 */
9767 345, /* B0 = 0.010540 */
9768 27240, /* A1 = -1.662598 */
9769 -32683, /* A2 = 0.997406 */
9770 22560, /* B2 = 0.688477 */
9771 -18688, /* B1 = -1.140625 */
9772 22560, /* B0 = 0.688477 */
9773 27461, /* A1 = -1.676147 */
9774 -32684, /* A2 = 0.997467 */
9775 3541, /* B2 = 0.108086 */
9776 -2985, /* B1 = -0.182220 */
9777 3541, /* B0 = 0.108086 */
9778 5, /* Internal filter scaling */
9779 159, /* Minimum in-band energy threshold */
9780 21, /* 21/32 in-band to broad-band ratio */
9781 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9782 },
9783 { /* f750 */
9784 27155, /* A1 = -1.657410 */
9785 -32551, /* A2 = 0.993408 */
9786 -462, /* B2 = -0.014117 */
9787 0, /* B1 = 0.000000 */
9788 462, /* B0 = 0.014117 */
9789 27097, /* A1 = -1.653870 */
9790 -32683, /* A2 = 0.997406 */
9791 32495, /* B2 = 0.991699 */
9792 -26776, /* B1 = -1.634338 */
9793 32495, /* B0 = 0.991699 */
9794 27321, /* A1 = -1.667542 */
9795 -32684, /* A2 = 0.997467 */
9796 1835, /* B2 = 0.056007 */
9797 -1539, /* B1 = -0.093948 */
9798 1835, /* B0 = 0.056007 */
9799 5, /* Internal filter scaling */
9800 159, /* Minimum in-band energy threshold */
9801 21, /* 21/32 in-band to broad-band ratio */
9802 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9803 },
9804 { /* f750_1450[] */
9805 19298, /* A1 = 1.177917 */
9806 -24471, /* A2 = -0.746796 */
9807 -4152, /* B2 = -0.126709 */
9808 0, /* B1 = 0 */
9809 4152, /* B0 = 0.126709 */
9810 12902, /* A1 = 0.787476 */
9811 -29091, /* A2 = -0.887817 */
9812 12491, /* B2 = 0.38121 */
9813 -1794, /* B1 = -0.109528 */
9814 12494, /* B0 = 0.381317 */
9815 26291, /* A1 = 1.604736 */
9816 -30470, /* A2 = -0.929901 */
9817 28859, /* B2 = 0.880737 */
9818 -26084, /* B1 = -1.592102 */
9819 28861, /* B0 = 0.880798 */
9820 7, /* Internal filter scaling */
9821 159, /* Minimum in-band energy threshold */
9822 21, /* 21/32 in-band to broad-band ratio */
9823 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9824 },
9825 { /* f770 */
9826 26867, /* A1 = -1.639832 */
9827 -32551, /* A2 = 0.993408 */
9828 -123, /* B2 = -0.003755 */
9829 0, /* B1 = 0.000000 */
9830 123, /* B0 = 0.003755 */
9831 26805, /* A1 = -1.636108 */
9832 -32683, /* A2 = 0.997406 */
9833 17297, /* B2 = 0.527863 */
9834 -14096, /* B1 = -0.860382 */
9835 17297, /* B0 = 0.527863 */
9836 27034, /* A1 = -1.650085 */
9837 -32684, /* A2 = 0.997467 */
9838 12958, /* B2 = 0.395477 */
9839 -10756, /* B1 = -0.656525 */
9840 12958, /* B0 = 0.395477 */
9841 5, /* Internal filter scaling */
9842 159, /* Minimum in-band energy threshold */
9843 21, /* 21/32 in-band to broad-band ratio */
9844 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9845 },
9846 { /* f800 */
9847 26413, /* A1 = -1.612122 */
9848 -32547, /* A2 = 0.993286 */
9849 -223, /* B2 = -0.006825 */
9850 0, /* B1 = 0.000000 */
9851 223, /* B0 = 0.006825 */
9852 26342, /* A1 = -1.607849 */
9853 -32686, /* A2 = 0.997498 */
9854 6391, /* B2 = 0.195053 */
9855 -5120, /* B1 = -0.312531 */
9856 6391, /* B0 = 0.195053 */
9857 26593, /* A1 = -1.623108 */
9858 -32688, /* A2 = 0.997559 */
9859 23681, /* B2 = 0.722717 */
9860 -19328, /* B1 = -1.179688 */
9861 23681, /* B0 = 0.722717 */
9862 5, /* Internal filter scaling */
9863 159, /* Minimum in-band energy threshold */
9864 21, /* 21/32 in-band to broad-band ratio */
9865 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9866 },
9867 { /* f816 */
9868 26168, /* A1 = -1.597209 */
9869 -32528, /* A2 = 0.992706 */
9870 -235, /* B2 = -0.007182 */
9871 0, /* B1 = 0.000000 */
9872 235, /* B0 = 0.007182 */
9873 26092, /* A1 = -1.592590 */
9874 -32675, /* A2 = 0.997192 */
9875 20823, /* B2 = 0.635498 */
9876 -16510, /* B1 = -1.007751 */
9877 20823, /* B0 = 0.635498 */
9878 26363, /* A1 = -1.609070 */
9879 -32677, /* A2 = 0.997253 */
9880 6739, /* B2 = 0.205688 */
9881 -5459, /* B1 = -0.333206 */
9882 6739, /* B0 = 0.205688 */
9883 5, /* Internal filter scaling */
9884 159, /* Minimum in-band energy threshold */
9885 21, /* 21/32 in-band to broad-band ratio */
9886 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9887 },
9888 { /* f850 */
9889 25641, /* A1 = -1.565063 */
9890 -32536, /* A2 = 0.992950 */
9891 -121, /* B2 = -0.003707 */
9892 0, /* B1 = 0.000000 */
9893 121, /* B0 = 0.003707 */
9894 25560, /* A1 = -1.560059 */
9895 -32684, /* A2 = 0.997437 */
9896 18341, /* B2 = 0.559753 */
9897 -14252, /* B1 = -0.869904 */
9898 18341, /* B0 = 0.559753 */
9899 25837, /* A1 = -1.577026 */
9900 -32684, /* A2 = 0.997467 */
9901 16679, /* B2 = 0.509003 */
9902 -13232, /* B1 = -0.807648 */
9903 16679, /* B0 = 0.509003 */
9904 5, /* Internal filter scaling */
9905 159, /* Minimum in-band energy threshold */
9906 21, /* 21/32 in-band to broad-band ratio */
9907 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9908 },
9909 { /* f857_1645[] */
9910 16415, /* A1 = 1.001953 */
9911 -23669, /* A2 = -0.722321 */
9912 -4549, /* B2 = -0.138847 */
9913 0, /* B1 = 0 */
9914 4549, /* B0 = 0.138847 */
9915 8456, /* A1 = 0.516174 */
9916 -28996, /* A2 = -0.884918 */
9917 13753, /* B2 = 0.419724 */
9918 -12, /* B1 = -0.000763 */
9919 13757, /* B0 = 0.419846 */
9920 24632, /* A1 = 1.503418 */
9921 -30271, /* A2 = -0.923828 */
9922 29070, /* B2 = 0.887146 */
9923 -25265, /* B1 = -1.542114 */
9924 29073, /* B0 = 0.887268 */
9925 7, /* Internal filter scaling */
9926 159, /* Minimum in-band energy threshold */
9927 21, /* 21/32 in-band to broad-band ratio */
9928 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9929 },
9930 { /* f900 */
9931 24806, /* A1 = -1.514099 */
9932 -32501, /* A2 = 0.991852 */
9933 -326, /* B2 = -0.009969 */
9934 0, /* B1 = 0.000000 */
9935 326, /* B0 = 0.009969 */
9936 24709, /* A1 = -1.508118 */
9937 -32659, /* A2 = 0.996674 */
9938 20277, /* B2 = 0.618835 */
9939 -15182, /* B1 = -0.926636 */
9940 20277, /* B0 = 0.618835 */
9941 25022, /* A1 = -1.527222 */
9942 -32661, /* A2 = 0.996735 */
9943 4320, /* B2 = 0.131836 */
9944 -3331, /* B1 = -0.203339 */
9945 4320, /* B0 = 0.131836 */
9946 5, /* Internal filter scaling */
9947 159, /* Minimum in-band energy threshold */
9948 21, /* 21/32 in-band to broad-band ratio */
9949 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9950 },
9951 { /* f900_1300[] */
9952 19776, /* A1 = 1.207092 */
9953 -27437, /* A2 = -0.837341 */
9954 -2666, /* B2 = -0.081371 */
9955 0, /* B1 = 0 */
9956 2666, /* B0 = 0.081371 */
9957 16302, /* A1 = 0.995026 */
9958 -30354, /* A2 = -0.926361 */
9959 10389, /* B2 = 0.317062 */
9960 -3327, /* B1 = -0.203064 */
9961 10389, /* B0 = 0.317062 */
9962 24299, /* A1 = 1.483154 */
9963 -30930, /* A2 = -0.943909 */
9964 25016, /* B2 = 0.763428 */
9965 -21171, /* B1 = -1.292236 */
9966 25016, /* B0 = 0.763428 */
9967 7, /* Internal filter scaling */
9968 159, /* Minimum in-band energy threshold */
9969 21, /* 21/32 in-band to broad-band ratio */
9970 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9971 },
9972 { /* f935_1215[] */
9973 20554, /* A1 = 1.254517 */
9974 -28764, /* A2 = -0.877838 */
9975 -2048, /* B2 = -0.062515 */
9976 0, /* B1 = 0 */
9977 2048, /* B0 = 0.062515 */
9978 18209, /* A1 = 1.11145 */
9979 -30951, /* A2 = -0.94458 */
9980 9390, /* B2 = 0.286575 */
9981 -3955, /* B1 = -0.241455 */
9982 9390, /* B0 = 0.286575 */
9983 23902, /* A1 = 1.458923 */
9984 -31286, /* A2 = -0.954803 */
9985 23252, /* B2 = 0.709595 */
9986 -19132, /* B1 = -1.167725 */
9987 23252, /* B0 = 0.709595 */
9988 7, /* Internal filter scaling */
9989 159, /* Minimum in-band energy threshold */
9990 21, /* 21/32 in-band to broad-band ratio */
9991 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9992 },
9993 { /* f941_1477[] */
9994 17543, /* A1 = 1.07074 */
9995 -26220, /* A2 = -0.800201 */
9996 -3298, /* B2 = -0.100647 */
9997 0, /* B1 = 0 */
9998 3298, /* B0 = 0.100647 */
9999 12423, /* A1 = 0.75827 */
10000 -30036, /* A2 = -0.916626 */
10001 12651, /* B2 = 0.386078 */
10002 -2444, /* B1 = -0.14917 */
10003 12653, /* B0 = 0.386154 */
10004 23518, /* A1 = 1.435425 */
10005 -30745, /* A2 = -0.938293 */
10006 27282, /* B2 = 0.832581 */
10007 -22529, /* B1 = -1.375122 */
10008 27286, /* B0 = 0.832703 */
10009 7, /* Internal filter scaling */
10010 159, /* Minimum in-band energy threshold */
10011 21, /* 21/32 in-band to broad-band ratio */
10012 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10013 },
10014 { /* f942 */
10015 24104, /* A1 = -1.471252 */
10016 -32507, /* A2 = 0.992065 */
10017 -351, /* B2 = -0.010722 */
10018 0, /* B1 = 0.000000 */
10019 351, /* B0 = 0.010722 */
10020 23996, /* A1 = -1.464600 */
10021 -32671, /* A2 = 0.997040 */
10022 22848, /* B2 = 0.697266 */
10023 -16639, /* B1 = -1.015564 */
10024 22848, /* B0 = 0.697266 */
10025 24332, /* A1 = -1.485168 */
10026 -32673, /* A2 = 0.997101 */
10027 4906, /* B2 = 0.149727 */
10028 -3672, /* B1 = -0.224174 */
10029 4906, /* B0 = 0.149727 */
10030 5, /* Internal filter scaling */
10031 159, /* Minimum in-band energy threshold */
10032 21, /* 21/32 in-band to broad-band ratio */
10033 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10034 },
10035 { /* f950 */
10036 23967, /* A1 = -1.462830 */
10037 -32507, /* A2 = 0.992065 */
10038 -518, /* B2 = -0.015821 */
10039 0, /* B1 = 0.000000 */
10040 518, /* B0 = 0.015821 */
10041 23856, /* A1 = -1.456055 */
10042 -32671, /* A2 = 0.997040 */
10043 26287, /* B2 = 0.802246 */
10044 -19031, /* B1 = -1.161560 */
10045 26287, /* B0 = 0.802246 */
10046 24195, /* A1 = -1.476746 */
10047 -32673, /* A2 = 0.997101 */
10048 2890, /* B2 = 0.088196 */
10049 -2151, /* B1 = -0.131317 */
10050 2890, /* B0 = 0.088196 */
10051 5, /* Internal filter scaling */
10052 159, /* Minimum in-band energy threshold */
10053 21, /* 21/32 in-band to broad-band ratio */
10054 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10055 },
10056 { /* f950_1400[] */
10057 18294, /* A1 = 1.116638 */
10058 -26962, /* A2 = -0.822845 */
10059 -2914, /* B2 = -0.088936 */
10060 0, /* B1 = 0 */
10061 2914, /* B0 = 0.088936 */
10062 14119, /* A1 = 0.861786 */
10063 -30227, /* A2 = -0.922455 */
10064 11466, /* B2 = 0.349945 */
10065 -2833, /* B1 = -0.172943 */
10066 11466, /* B0 = 0.349945 */
10067 23431, /* A1 = 1.430115 */
10068 -30828, /* A2 = -0.940796 */
10069 25331, /* B2 = 0.773071 */
10070 -20911, /* B1 = -1.276367 */
10071 25331, /* B0 = 0.773071 */
10072 7, /* Internal filter scaling */
10073 159, /* Minimum in-band energy threshold */
10074 21, /* 21/32 in-band to broad-band ratio */
10075 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10076 },
10077 { /* f975 */
10078 23521, /* A1 = -1.435608 */
10079 -32489, /* A2 = 0.991516 */
10080 -193, /* B2 = -0.005915 */
10081 0, /* B1 = 0.000000 */
10082 193, /* B0 = 0.005915 */
10083 23404, /* A1 = -1.428467 */
10084 -32655, /* A2 = 0.996582 */
10085 17740, /* B2 = 0.541412 */
10086 -12567, /* B1 = -0.767029 */
10087 17740, /* B0 = 0.541412 */
10088 23753, /* A1 = -1.449829 */
10089 -32657, /* A2 = 0.996613 */
10090 9090, /* B2 = 0.277405 */
10091 -6662, /* B1 = -0.406647 */
10092 9090, /* B0 = 0.277405 */
10093 5, /* Internal filter scaling */
10094 159, /* Minimum in-band energy threshold */
10095 21, /* 21/32 in-band to broad-band ratio */
10096 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10097 },
10098 { /* f1000 */
10099 23071, /* A1 = -1.408203 */
10100 -32489, /* A2 = 0.991516 */
10101 -293, /* B2 = -0.008965 */
10102 0, /* B1 = 0.000000 */
10103 293, /* B0 = 0.008965 */
10104 22951, /* A1 = -1.400818 */
10105 -32655, /* A2 = 0.996582 */
10106 5689, /* B2 = 0.173645 */
10107 -3951, /* B1 = -0.241150 */
10108 5689, /* B0 = 0.173645 */
10109 23307, /* A1 = -1.422607 */
10110 -32657, /* A2 = 0.996613 */
10111 18692, /* B2 = 0.570435 */
10112 -13447, /* B1 = -0.820770 */
10113 18692, /* B0 = 0.570435 */
10114 5, /* Internal filter scaling */
10115 159, /* Minimum in-band energy threshold */
10116 21, /* 21/32 in-band to broad-band ratio */
10117 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10118 },
10119 { /* f1020 */
10120 22701, /* A1 = -1.385620 */
10121 -32474, /* A2 = 0.991058 */
10122 -292, /* B2 = -0.008933 */
10123 0, /*163840 , B1 = 10.000000 */
10124 292, /* B0 = 0.008933 */
10125 22564, /* A1 = -1.377258 */
10126 -32655, /* A2 = 0.996552 */
10127 20756, /* B2 = 0.633423 */
10128 -14176, /* B1 = -0.865295 */
10129 20756, /* B0 = 0.633423 */
10130 22960, /* A1 = -1.401428 */
10131 -32657, /* A2 = 0.996613 */
10132 6520, /* B2 = 0.198990 */
10133 -4619, /* B1 = -0.281937 */
10134 6520, /* B0 = 0.198990 */
10135 5, /* Internal filter scaling */
10136 159, /* Minimum in-band energy threshold */
10137 21, /* 21/32 in-band to broad-band ratio */
10138 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10139 },
10140 { /* f1050 */
10141 22142, /* A1 = -1.351501 */
10142 -32474, /* A2 = 0.991058 */
10143 -147, /* B2 = -0.004493 */
10144 0, /* B1 = 0.000000 */
10145 147, /* B0 = 0.004493 */
10146 22000, /* A1 = -1.342834 */
10147 -32655, /* A2 = 0.996552 */
10148 15379, /* B2 = 0.469360 */
10149 -10237, /* B1 = -0.624847 */
10150 15379, /* B0 = 0.469360 */
10151 22406, /* A1 = -1.367554 */
10152 -32657, /* A2 = 0.996613 */
10153 17491, /* B2 = 0.533783 */
10154 -12096, /* B1 = -0.738312 */
10155 17491, /* B0 = 0.533783 */
10156 5, /* Internal filter scaling */
10157 159, /* Minimum in-band energy threshold */
10158 21, /* 21/32 in-band to broad-band ratio */
10159 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10160 },
10161 { /* f1100_1750[] */
10162 12973, /* A1 = 0.79184 */
10163 -24916, /* A2 = -0.760376 */
10164 6655, /* B2 = 0.203102 */
10165 367, /* B1 = 0.0224 */
10166 6657, /* B0 = 0.203171 */
10167 5915, /* A1 = 0.361053 */
10168 -29560, /* A2 = -0.90213 */
10169 -7777, /* B2 = -0.23735 */
10170 0, /* B1 = 0 */
10171 7777, /* B0 = 0.23735 */
10172 20510, /* A1 = 1.251892 */
10173 -30260, /* A2 = -0.923462 */
10174 26662, /* B2 = 0.81366 */
10175 -20573, /* B1 = -1.255737 */
10176 26668, /* B0 = 0.813843 */
10177 7, /* Internal filter scaling */
10178 159, /* Minimum in-band energy threshold */
10179 21, /* 21/32 in-band to broad-band ratio */
10180 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10181 },
10182 { /* f1140 */
10183 20392, /* A1 = -1.244629 */
10184 -32460, /* A2 = 0.990601 */
10185 -270, /* B2 = -0.008240 */
10186 0, /* B1 = 0.000000 */
10187 270, /* B0 = 0.008240 */
10188 20218, /* A1 = -1.234009 */
10189 -32655, /* A2 = 0.996582 */
10190 21337, /* B2 = 0.651154 */
10191 -13044, /* B1 = -0.796143 */
10192 21337, /* B0 = 0.651154 */
10193 20684, /* A1 = -1.262512 */
10194 -32657, /* A2 = 0.996643 */
10195 8572, /* B2 = 0.261612 */
10196 -5476, /* B1 = -0.334244 */
10197 8572, /* B0 = 0.261612 */
10198 5, /* Internal filter scaling */
10199 159, /* Minimum in-band energy threshold */
10200 21, /* 21/32 in-band to broad-band ratio */
10201 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10202 },
10203 { /* f1200 */
10204 19159, /* A1 = -1.169373 */
10205 -32456, /* A2 = 0.990509 */
10206 -335, /* B2 = -0.010252 */
10207 0, /* B1 = 0.000000 */
10208 335, /* B0 = 0.010252 */
10209 18966, /* A1 = -1.157593 */
10210 -32661, /* A2 = 0.996735 */
10211 6802, /* B2 = 0.207588 */
10212 -3900, /* B1 = -0.238098 */
10213 6802, /* B0 = 0.207588 */
10214 19467, /* A1 = -1.188232 */
10215 -32661, /* A2 = 0.996765 */
10216 25035, /* B2 = 0.764008 */
10217 -15049, /* B1 = -0.918579 */
10218 25035, /* B0 = 0.764008 */
10219 5, /* Internal filter scaling */
10220 159, /* Minimum in-band energy threshold */
10221 21, /* 21/32 in-band to broad-band ratio */
10222 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10223 },
10224 { /* f1209 */
10225 18976, /* A1 = -1.158264 */
10226 -32439, /* A2 = 0.989990 */
10227 -183, /* B2 = -0.005588 */
10228 0, /* B1 = 0.000000 */
10229 183, /* B0 = 0.005588 */
10230 18774, /* A1 = -1.145874 */
10231 -32650, /* A2 = 0.996429 */
10232 15468, /* B2 = 0.472076 */
10233 -8768, /* B1 = -0.535217 */
10234 15468, /* B0 = 0.472076 */
10235 19300, /* A1 = -1.177979 */
10236 -32652, /* A2 = 0.996490 */
10237 19840, /* B2 = 0.605499 */
10238 -11842, /* B1 = -0.722809 */
10239 19840, /* B0 = 0.605499 */
10240 5, /* Internal filter scaling */
10241 159, /* Minimum in-band energy threshold */
10242 21, /* 21/32 in-band to broad-band ratio */
10243 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10244 },
10245 { /* f1330 */
10246 16357, /* A1 = -0.998413 */
10247 -32368, /* A2 = 0.987793 */
10248 -217, /* B2 = -0.006652 */
10249 0, /* B1 = 0.000000 */
10250 217, /* B0 = 0.006652 */
10251 16107, /* A1 = -0.983126 */
10252 -32601, /* A2 = 0.994904 */
10253 11602, /* B2 = 0.354065 */
10254 -5555, /* B1 = -0.339111 */
10255 11602, /* B0 = 0.354065 */
10256 16722, /* A1 = -1.020630 */
10257 -32603, /* A2 = 0.994965 */
10258 15574, /* B2 = 0.475311 */
10259 -8176, /* B1 = -0.499069 */
10260 15574, /* B0 = 0.475311 */
10261 5, /* Internal filter scaling */
10262 159, /* Minimum in-band energy threshold */
10263 21, /* 21/32 in-band to broad-band ratio */
10264 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10265 },
10266 { /* f1336 */
10267 16234, /* A1 = -0.990875 */
10268 32404, /* A2 = -0.988922 */
10269 -193, /* B2 = -0.005908 */
10270 0, /* B1 = 0.000000 */
10271 193, /* B0 = 0.005908 */
10272 15986, /* A1 = -0.975769 */
10273 -32632, /* A2 = 0.995880 */
10274 18051, /* B2 = 0.550903 */
10275 -8658, /* B1 = -0.528473 */
10276 18051, /* B0 = 0.550903 */
10277 16591, /* A1 = -1.012695 */
10278 -32634, /* A2 = 0.995941 */
10279 15736, /* B2 = 0.480240 */
10280 -8125, /* B1 = -0.495926 */
10281 15736, /* B0 = 0.480240 */
10282 5, /* Internal filter scaling */
10283 159, /* Minimum in-band energy threshold */
10284 21, /* 21/32 in-band to broad-band ratio */
10285 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10286 },
10287 { /* f1366 */
10288 15564, /* A1 = -0.949982 */
10289 -32404, /* A2 = 0.988922 */
10290 -269, /* B2 = -0.008216 */
10291 0, /* B1 = 0.000000 */
10292 269, /* B0 = 0.008216 */
10293 15310, /* A1 = -0.934479 */
10294 -32632, /* A2 = 0.995880 */
10295 10815, /* B2 = 0.330063 */
10296 -4962, /* B1 = -0.302887 */
10297 10815, /* B0 = 0.330063 */
10298 15924, /* A1 = -0.971924 */
10299 -32634, /* A2 = 0.995941 */
10300 18880, /* B2 = 0.576172 */
10301 -9364, /* B1 = -0.571594 */
10302 18880, /* B0 = 0.576172 */
10303 5, /* Internal filter scaling */
10304 159, /* Minimum in-band energy threshold */
10305 21, /* 21/32 in-band to broad-band ratio */
10306 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10307 },
10308 { /* f1380 */
10309 15247, /* A1 = -0.930603 */
10310 -32397, /* A2 = 0.988708 */
10311 -244, /* B2 = -0.007451 */
10312 0, /* B1 = 0.000000 */
10313 244, /* B0 = 0.007451 */
10314 14989, /* A1 = -0.914886 */
10315 -32627, /* A2 = 0.995697 */
10316 18961, /* B2 = 0.578644 */
10317 -8498, /* B1 = -0.518707 */
10318 18961, /* B0 = 0.578644 */
10319 15608, /* A1 = -0.952667 */
10320 -32628, /* A2 = 0.995758 */
10321 11145, /* B2 = 0.340134 */
10322 -5430, /* B1 = -0.331467 */
10323 11145, /* B0 = 0.340134 */
10324 5, /* Internal filter scaling */
10325 159, /* Minimum in-band energy threshold */
10326 21, /* 21/32 in-band to broad-band ratio */
10327 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10328 },
10329 { /* f1400 */
10330 14780, /* A1 = -0.902130 */
10331 -32393, /* A2 = 0.988586 */
10332 -396, /* B2 = -0.012086 */
10333 0, /* B1 = 0.000000 */
10334 396, /* B0 = 0.012086 */
10335 14510, /* A1 = -0.885651 */
10336 -32630, /* A2 = 0.995819 */
10337 6326, /* B2 = 0.193069 */
10338 -2747, /* B1 = -0.167671 */
10339 6326, /* B0 = 0.193069 */
10340 15154, /* A1 = -0.924957 */
10341 -32632, /* A2 = 0.995850 */
10342 23235, /* B2 = 0.709076 */
10343 -10983, /* B1 = -0.670380 */
10344 23235, /* B0 = 0.709076 */
10345 5, /* Internal filter scaling */
10346 159, /* Minimum in-band energy threshold */
10347 21, /* 21/32 in-band to broad-band ratio */
10348 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10349 },
10350 { /* f1477 */
10351 13005, /* A1 = -0.793793 */
10352 -32368, /* A2 = 0.987823 */
10353 -500, /* B2 = -0.015265 */
10354 0, /* B1 = 0.000000 */
10355 500, /* B0 = 0.015265 */
10356 12708, /* A1 = -0.775665 */
10357 -32615, /* A2 = 0.995331 */
10358 11420, /* B2 = 0.348526 */
10359 -4306, /* B1 = -0.262833 */
10360 11420, /* B0 = 0.348526 */
10361 13397, /* A1 = -0.817688 */
10362 -32615, /* A2 = 0.995361 */
10363 9454, /* B2 = 0.288528 */
10364 -3981, /* B1 = -0.243027 */
10365 9454, /* B0 = 0.288528 */
10366 5, /* Internal filter scaling */
10367 159, /* Minimum in-band energy threshold */
10368 21, /* 21/32 in-band to broad-band ratio */
10369 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10370 },
10371 { /* f1600 */
10372 10046, /* A1 = -0.613190 */
10373 -32331, /* A2 = 0.986694 */
10374 -455, /* B2 = -0.013915 */
10375 0, /* B1 = 0.000000 */
10376 455, /* B0 = 0.013915 */
10377 9694, /* A1 = -0.591705 */
10378 -32601, /* A2 = 0.994934 */
10379 6023, /* B2 = 0.183815 */
10380 -1708, /* B1 = -0.104279 */
10381 6023, /* B0 = 0.183815 */
10382 10478, /* A1 = -0.639587 */
10383 -32603, /* A2 = 0.994965 */
10384 22031, /* B2 = 0.672333 */
10385 -7342, /* B1 = -0.448151 */
10386 22031, /* B0 = 0.672333 */
10387 5, /* Internal filter scaling */
10388 159, /* Minimum in-band energy threshold */
10389 21, /* 21/32 in-band to broad-band ratio */
10390 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10391 },
10392 { /* f1633_1638[] */
10393 9181, /* A1 = 0.560394 */
10394 -32256, /* A2 = -0.984375 */
10395 -556, /* B2 = -0.016975 */
10396 0, /* B1 = 0 */
10397 556, /* B0 = 0.016975 */
10398 8757, /* A1 = 0.534515 */
10399 -32574, /* A2 = -0.99408 */
10400 8443, /* B2 = 0.25769 */
10401 -2135, /* B1 = -0.130341 */
10402 8443, /* B0 = 0.25769 */
10403 9691, /* A1 = 0.591522 */
10404 -32574, /* A2 = -0.99411 */
10405 15446, /* B2 = 0.471375 */
10406 -4809, /* B1 = -0.293579 */
10407 15446, /* B0 = 0.471375 */
10408 7, /* Internal filter scaling */
10409 159, /* Minimum in-band energy threshold */
10410 21, /* 21/32 in-band to broad-band ratio */
10411 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10412 },
10413 { /* f1800 */
10414 5076, /* A1 = -0.309875 */
10415 -32304, /* A2 = 0.985840 */
10416 -508, /* B2 = -0.015503 */
10417 0, /* B1 = 0.000000 */
10418 508, /* B0 = 0.015503 */
10419 4646, /* A1 = -0.283600 */
10420 -32605, /* A2 = 0.995026 */
10421 6742, /* B2 = 0.205780 */
10422 -878, /* B1 = -0.053635 */
10423 6742, /* B0 = 0.205780 */
10424 5552, /* A1 = -0.338928 */
10425 -32605, /* A2 = 0.995056 */
10426 23667, /* B2 = 0.722260 */
10427 -4297, /* B1 = -0.262329 */
10428 23667, /* B0 = 0.722260 */
10429 5, /* Internal filter scaling */
10430 159, /* Minimum in-band energy threshold */
10431 21, /* 21/32 in-band to broad-band ratio */
10432 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10433 },
10434 { /* f1860 */
10435 3569, /* A1 = -0.217865 */
10436 -32292, /* A2 = 0.985504 */
10437 -239, /* B2 = -0.007322 */
10438 0, /* B1 = 0.000000 */
10439 239, /* B0 = 0.007322 */
10440 3117, /* A1 = -0.190277 */
10441 -32603, /* A2 = 0.994965 */
10442 18658, /* B2 = 0.569427 */
10443 -1557, /* B1 = -0.095032 */
10444 18658, /* B0 = 0.569427 */
10445 4054, /* A1 = -0.247437 */
10446 -32603, /* A2 = 0.994965 */
10447 18886, /* B2 = 0.576385 */
10448 -2566, /* B1 = -0.156647 */
10449 18886, /* B0 = 0.576385 */
10450 5, /* Internal filter scaling */
10451 159, /* Minimum in-band energy threshold */
10452 21, /* 21/32 in-band to broad-band ratio */
10453 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10454 },
10455 };
10456 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10457 {
10458 unsigned short cmd;
10459 int cnt, max;
10460
10461 if (jf->filter > 3) {
10462 return -1;
10463 }
10464 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10465
10466 return -1;
10467 if (!jf->enable) {
10468 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10469
10470 return -1;
10471 else
10472 return 0;
10473 } else {
10474 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10475
10476 return -1;
10477 /* Select the filter (f0 - f3) to use. */
10478 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10479 return -1;
10480 }
10481 if (jf->freq < 12 && jf->freq > 3) {
10482 /* Select the frequency for the selected filter. */
10483 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10484 return -1;
10485 } else if (jf->freq > 11) {
10486 /* We need to load a programmable filter set for undefined */
10487 /* frequencies. So we will point the filter to a programmable set. */
10488 /* Since there are only 4 filters and 4 programmable sets, we will */
10489 /* just point the filter to the same number set and program it for the */
10490 /* frequency we want. */
10491 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10492 return -1;
10493 if (j->ver.low != 0x12) {
10494 cmd = 0x515B;
10495 max = 19;
10496 } else {
10497 cmd = 0x515E;
10498 max = 15;
10499 }
10500 if (ixj_WriteDSPCommand(cmd, j))
10501 return -1;
10502 for (cnt = 0; cnt < max; cnt++) {
10503 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10504 return -1;
10505 }
10506 }
10507 j->filter_en[jf->filter] = jf->enable;
10508 return 0;
10509 }
10510
10511 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10512 {
10513 unsigned short cmd;
10514 int cnt, max;
10515 if (jfr->filter > 3) {
10516 return -1;
10517 }
10518 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10519 return -1;
10520
10521 if (!jfr->enable) {
10522 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10523 return -1;
10524 else
10525 return 0;
10526 } else {
10527 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10528 return -1;
10529 /* Select the filter (f0 - f3) to use. */
10530 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10531 return -1;
10532 }
10533 /* We need to load a programmable filter set for undefined */
10534 /* frequencies. So we will point the filter to a programmable set. */
10535 /* Since there are only 4 filters and 4 programmable sets, we will */
10536 /* just point the filter to the same number set and program it for the */
10537 /* frequency we want. */
10538 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10539 return -1;
10540 if (j->ver.low != 0x12) {
10541 cmd = 0x515B;
10542 max = 19;
10543 } else {
10544 cmd = 0x515E;
10545 max = 15;
10546 }
10547 if (ixj_WriteDSPCommand(cmd, j))
10548 return -1;
10549 for (cnt = 0; cnt < max; cnt++) {
10550 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10551 return -1;
10552 }
10553 j->filter_en[jfr->filter] = jfr->enable;
10554 return 0;
10555 }
10556
10557 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10558 {
10559 int freq0, freq1;
10560 unsigned short data;
10561 if (ti->freq0) {
10562 freq0 = ti->freq0;
10563 } else {
10564 freq0 = 0x7FFF;
10565 }
10566
10567 if (ti->freq1) {
10568 freq1 = ti->freq1;
10569 } else {
10570 freq1 = 0x7FFF;
10571 }
10572
10573 if(ti->tone_index > 12 && ti->tone_index < 28)
10574 {
10575 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10576 return -1;
10577 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10578 return -1;
10579 data = freq0;
10580 if (ixj_WriteDSPCommand(data, j))
10581 return -1;
10582 data = freq1;
10583 if (ixj_WriteDSPCommand(data, j))
10584 return -1;
10585 }
10586 return freq0;
10587 }
10588
linux-next