]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/telephony/ixj.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / drivers / telephony / ixj.c
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 static char ixj_c_rcsid[] = "$Id: ixj.c,v 4.7 2001/08/13 06:19:33 craigs Exp $";
45 static char ixj_c_revision[] = "$Revision: 4.7 $";
46
47 /*
48 * $Log: ixj.c,v $
49 *
50 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
51 * Audit some copy_*_user and minor cleanup.
52 *
53 * Revision 4.7 2001/08/13 06:19:33 craigs
54 * Added additional changes from Alan Cox and John Anderson for
55 * 2.2 to 2.4 cleanup and bounds checking
56 *
57 * Revision 4.6 2001/08/13 01:05:05 craigs
58 * Really fixed PHONE_QUERY_CODEC problem this time
59 *
60 * Revision 4.5 2001/08/13 00:11:03 craigs
61 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
62 *
63 * Revision 4.4 2001/08/07 07:58:12 craigs
64 * Changed back to three digit version numbers
65 * Added tagbuild target to allow automatic and easy tagging of versions
66 *
67 * Revision 4.3 2001/08/07 07:24:47 craigs
68 * Added ixj-ver.h to allow easy configuration management of driver
69 * Added display of version number in /prox/ixj
70 *
71 * Revision 4.2 2001/08/06 07:07:19 craigs
72 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
73 * behaviour of returning int rather than short *
74 *
75 * Revision 4.1 2001/08/05 00:17:37 craigs
76 * More changes for correct PCMCIA installation
77 * Start of changes for backward Linux compatibility
78 *
79 * Revision 4.0 2001/08/04 12:33:12 craigs
80 * New version using GNU autoconf
81 *
82 * Revision 3.105 2001/07/20 23:14:32 eokerson
83 * More work on CallerID generation when using ring cadences.
84 *
85 * Revision 3.104 2001/07/06 01:33:55 eokerson
86 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
87 *
88 * Revision 3.103 2001/07/05 19:20:16 eokerson
89 * Updated HOWTO
90 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
91 *
92 * Revision 3.102 2001/07/03 23:51:21 eokerson
93 * Un-mute mic on Internet LineJACK when in speakerphone mode.
94 *
95 * Revision 3.101 2001/07/02 19:26:56 eokerson
96 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
97 *
98 * Revision 3.100 2001/07/02 19:18:27 eokerson
99 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
100 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
101 * Fixed speaker mode on Internet LineJACK.
102 *
103 * Revision 3.99 2001/05/09 14:11:16 eokerson
104 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
105 *
106 * Revision 3.98 2001/05/08 19:55:33 eokerson
107 * Fixed POTS hookstate detection while it is connected to PSTN port.
108 *
109 * Revision 3.97 2001/05/08 00:01:04 eokerson
110 * Fixed kernel oops when sending caller ID data.
111 *
112 * Revision 3.96 2001/05/04 23:09:30 eokerson
113 * Now uses one kernel timer for each card, instead of one for the entire driver.
114 *
115 * Revision 3.95 2001/04/25 22:06:47 eokerson
116 * Fixed squawking at beginning of some G.723.1 calls.
117 *
118 * Revision 3.94 2001/04/03 23:42:00 eokerson
119 * Added linear volume ioctls
120 * Added raw filter load ioctl
121 *
122 * Revision 3.93 2001/02/27 01:00:06 eokerson
123 * Fixed blocking in CallerID.
124 * Reduced size of ixj structure for smaller driver footprint.
125 *
126 * Revision 3.92 2001/02/20 22:02:59 eokerson
127 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
128 * Improved PSTN ring detection.
129 * Fixed wink generation on POTS ports.
130 *
131 * Revision 3.91 2001/02/13 00:55:44 eokerson
132 * Turn AEC back on after changing frame sizes.
133 *
134 * Revision 3.90 2001/02/12 16:42:00 eokerson
135 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
136 *
137 * Revision 3.89 2001/02/12 15:41:16 eokerson
138 * Fix from Artis Kugevics - Tone gains were not being set correctly.
139 *
140 * Revision 3.88 2001/02/05 23:25:42 eokerson
141 * Fixed lockup bugs with deregister.
142 *
143 * Revision 3.87 2001/01/29 21:00:39 eokerson
144 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
145 * Updated copyright date.
146 *
147 * Revision 3.86 2001/01/23 23:53:46 eokerson
148 * Fixes to G.729 compatibility.
149 *
150 * Revision 3.85 2001/01/23 21:30:36 eokerson
151 * Added verbage about cards supported.
152 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
153 *
154 * Revision 3.84 2001/01/22 23:32:10 eokerson
155 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
156 *
157 * Revision 3.83 2001/01/19 14:51:41 eokerson
158 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
159 *
160 * Revision 3.82 2001/01/19 00:34:49 eokerson
161 * Added verbosity to write overlap errors.
162 *
163 * Revision 3.81 2001/01/18 23:56:54 eokerson
164 * Fixed PSTN line test functions.
165 *
166 * Revision 3.80 2001/01/18 22:29:27 eokerson
167 * Updated AEC/AGC values for different cards.
168 *
169 * Revision 3.79 2001/01/17 02:58:54 eokerson
170 * Fixed AEC reset after Caller ID.
171 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
172 *
173 * Revision 3.78 2001/01/16 19:43:09 eokerson
174 * Added support for Linux 2.4.x kernels.
175 *
176 * Revision 3.77 2001/01/09 04:00:52 eokerson
177 * Linetest will now test the line, even if it has previously succeded.
178 *
179 * Revision 3.76 2001/01/08 19:27:00 eokerson
180 * Fixed problem with standard cable on Internet PhoneCARD.
181 *
182 * Revision 3.75 2000/12/22 16:52:14 eokerson
183 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
184 *
185 * Revision 3.74 2000/12/08 22:41:50 eokerson
186 * Added capability for G729B.
187 *
188 * Revision 3.73 2000/12/07 23:35:16 eokerson
189 * Added capability to have different ring pattern before CallerID data.
190 * Added hookstate checks in CallerID routines to stop FSK.
191 *
192 * Revision 3.72 2000/12/06 19:31:31 eokerson
193 * Modified signal behavior to only send one signal per event.
194 *
195 * Revision 3.71 2000/12/06 03:23:08 eokerson
196 * Fixed CallerID on Call Waiting.
197 *
198 * Revision 3.70 2000/12/04 21:29:37 eokerson
199 * Added checking to Smart Cable gain functions.
200 *
201 * Revision 3.69 2000/12/04 21:05:20 eokerson
202 * Changed ixjdebug levels.
203 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
204 *
205 * Revision 3.68 2000/12/04 00:17:21 craigs
206 * Changed mixer voice gain to +6dB rather than 0dB
207 *
208 * Revision 3.67 2000/11/30 21:25:51 eokerson
209 * Fixed write signal errors.
210 *
211 * Revision 3.66 2000/11/29 22:42:44 eokerson
212 * Fixed PSTN ring detect problems.
213 *
214 * Revision 3.65 2000/11/29 07:31:55 craigs
215 * Added new 425Hz filter co-efficients
216 * Added card-specific DTMF prescaler initialisation
217 *
218 * Revision 3.64 2000/11/28 14:03:32 craigs
219 * Changed certain mixer initialisations to be 0dB rather than 12dB
220 * Added additional information to /proc/ixj
221 *
222 * Revision 3.63 2000/11/28 11:38:41 craigs
223 * Added display of AEC modes in AUTO and AGC mode
224 *
225 * Revision 3.62 2000/11/28 04:05:44 eokerson
226 * Improved PSTN ring detection routine.
227 *
228 * Revision 3.61 2000/11/27 21:53:12 eokerson
229 * Fixed flash detection.
230 *
231 * Revision 3.60 2000/11/27 15:57:29 eokerson
232 * More work on G.729 load routines.
233 *
234 * Revision 3.59 2000/11/25 21:55:12 eokerson
235 * Fixed errors in G.729 load routine.
236 *
237 * Revision 3.58 2000/11/25 04:08:29 eokerson
238 * Added board locks around G.729 and TS85 load routines.
239 *
240 * Revision 3.57 2000/11/24 05:35:17 craigs
241 * Added ability to retrieve mixer values on LineJACK
242 * Added complete initialisation of all mixer values at startup
243 * Fixed spelling mistake
244 *
245 * Revision 3.56 2000/11/23 02:52:11 robertj
246 * Added cvs change log keyword.
247 * Fixed bug in capabilities list when using G.729 module.
248 *
249 */
250
251 #include "ixj-ver.h"
252
253 #define PERFMON_STATS
254 #define IXJDEBUG 0
255 #define MAXRINGS 5
256
257 #include <linux/module.h>
258
259 #include <linux/init.h>
260 #include <linux/sched.h>
261 #include <linux/kernel.h> /* printk() */
262 #include <linux/fs.h> /* everything... */
263 #include <linux/errno.h> /* error codes */
264 #include <linux/slab.h>
265 #include <linux/mm.h>
266 #include <linux/ioport.h>
267 #include <linux/interrupt.h>
268 #include <linux/proc_fs.h>
269 #include <linux/poll.h>
270 #include <linux/timer.h>
271 #include <linux/delay.h>
272 #include <linux/pci.h>
273
274 #include <asm/io.h>
275 #include <asm/uaccess.h>
276
277 #include <linux/isapnp.h>
278
279 #include "ixj.h"
280
281 #define TYPE(inode) (iminor(inode) >> 4)
282 #define NUM(inode) (iminor(inode) & 0xf)
283
284 static int ixjdebug;
285 static int hertz = HZ;
286 static int samplerate = 100;
287
288 module_param(ixjdebug, int, 0);
289
290 /************************************************************************
291 *
292 * ixjdebug meanings are now bit mapped instead of level based
293 * Values can be or'ed together to turn on multiple messages
294 *
295 * bit 0 (0x0001) = any failure
296 * bit 1 (0x0002) = general messages
297 * bit 2 (0x0004) = POTS ringing related
298 * bit 3 (0x0008) = PSTN events
299 * bit 4 (0x0010) = PSTN Cadence state details
300 * bit 5 (0x0020) = Tone detection triggers
301 * bit 6 (0x0040) = Tone detection cadence details
302 * bit 7 (0x0080) = ioctl tracking
303 * bit 8 (0x0100) = signal tracking
304 * bit 9 (0x0200) = CallerID generation details
305 *
306 ************************************************************************/
307
308 #ifdef IXJ_DYN_ALLOC
309
310 static IXJ *ixj[IXJMAX];
311 #define get_ixj(b) ixj[(b)]
312
313 /*
314 * Allocate a free IXJ device
315 */
316
317 static IXJ *ixj_alloc()
318 {
319 for(cnt=0; cnt<IXJMAX; cnt++)
320 {
321 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
322 {
323 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
324 if (j == NULL)
325 return NULL;
326 ixj[cnt] = j;
327 return j;
328 }
329 }
330 return NULL;
331 }
332
333 static void ixj_fsk_free(IXJ *j)
334 {
335 if(j->fskdata != NULL) {
336 kfree(j->fskdata);
337 j->fskdata = NULL;
338 }
339 }
340
341 static void ixj_fsk_alloc(IXJ *j)
342 {
343 if(!j->fskdata) {
344 j->fskdata = kmalloc(8000, GFP_KERNEL);
345 if (!j->fskdata) {
346 if(ixjdebug & 0x0200) {
347 printk("IXJ phone%d - allocate failed\n", j->board);
348 }
349 return;
350 } else {
351 j->fsksize = 8000;
352 if(ixjdebug & 0x0200) {
353 printk("IXJ phone%d - allocate succeded\n", j->board);
354 }
355 }
356 }
357 }
358
359 #else
360
361 static IXJ ixj[IXJMAX];
362 #define get_ixj(b) (&ixj[(b)])
363
364 /*
365 * Allocate a free IXJ device
366 */
367
368 static IXJ *ixj_alloc(void)
369 {
370 int cnt;
371 for(cnt=0; cnt<IXJMAX; cnt++) {
372 if(!ixj[cnt].DSPbase)
373 return &ixj[cnt];
374 }
375 return NULL;
376 }
377
378 static inline void ixj_fsk_free(IXJ *j) {;}
379
380 static inline void ixj_fsk_alloc(IXJ *j)
381 {
382 j->fsksize = 8000;
383 }
384
385 #endif
386
387 #ifdef PERFMON_STATS
388 #define ixj_perfmon(x) ((x)++)
389 #else
390 #define ixj_perfmon(x) do { } while(0)
391 #endif
392
393 static int ixj_convert_loaded;
394
395 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
396
397 /************************************************************************
398 *
399 * These are function definitions to allow external modules to register
400 * enhanced functionality call backs.
401 *
402 ************************************************************************/
403
404 static int Stub(IXJ * J, unsigned long arg)
405 {
406 return 0;
407 }
408
409 static IXJ_REGFUNC ixj_PreRead = &Stub;
410 static IXJ_REGFUNC ixj_PostRead = &Stub;
411 static IXJ_REGFUNC ixj_PreWrite = &Stub;
412 static IXJ_REGFUNC ixj_PostWrite = &Stub;
413
414 static void ixj_read_frame(IXJ *j);
415 static void ixj_write_frame(IXJ *j);
416 static void ixj_init_timer(IXJ *j);
417 static void ixj_add_timer(IXJ * j);
418 static void ixj_timeout(unsigned long ptr);
419 static int read_filters(IXJ *j);
420 static int LineMonitor(IXJ *j);
421 static int ixj_fasync(int fd, struct file *, int mode);
422 static int ixj_set_port(IXJ *j, int arg);
423 static int ixj_set_pots(IXJ *j, int arg);
424 static int ixj_hookstate(IXJ *j);
425 static int ixj_record_start(IXJ *j);
426 static void ixj_record_stop(IXJ *j);
427 static void set_rec_volume(IXJ *j, int volume);
428 static int get_rec_volume(IXJ *j);
429 static int set_rec_codec(IXJ *j, int rate);
430 static void ixj_vad(IXJ *j, int arg);
431 static int ixj_play_start(IXJ *j);
432 static void ixj_play_stop(IXJ *j);
433 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
434 static int ixj_set_tone_off(unsigned short, IXJ *j);
435 static int ixj_play_tone(IXJ *j, char tone);
436 static void ixj_aec_start(IXJ *j, int level);
437 static int idle(IXJ *j);
438 static void ixj_ring_on(IXJ *j);
439 static void ixj_ring_off(IXJ *j);
440 static void aec_stop(IXJ *j);
441 static void ixj_ringback(IXJ *j);
442 static void ixj_busytone(IXJ *j);
443 static void ixj_dialtone(IXJ *j);
444 static void ixj_cpt_stop(IXJ *j);
445 static char daa_int_read(IXJ *j);
446 static char daa_CR_read(IXJ *j, int cr);
447 static int daa_set_mode(IXJ *j, int mode);
448 static int ixj_linetest(IXJ *j);
449 static int ixj_daa_write(IXJ *j);
450 static int ixj_daa_cid_read(IXJ *j);
451 static void DAA_Coeff_US(IXJ *j);
452 static void DAA_Coeff_UK(IXJ *j);
453 static void DAA_Coeff_France(IXJ *j);
454 static void DAA_Coeff_Germany(IXJ *j);
455 static void DAA_Coeff_Australia(IXJ *j);
456 static void DAA_Coeff_Japan(IXJ *j);
457 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
458 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
459 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
460 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
461 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
462 /* Serial Control Interface funtions */
463 static int SCI_Control(IXJ *j, int control);
464 static int SCI_Prepare(IXJ *j);
465 static int SCI_WaitHighSCI(IXJ *j);
466 static int SCI_WaitLowSCI(IXJ *j);
467 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
468 static int ixj_PCcontrol_wait(IXJ *j);
469 static void ixj_pre_cid(IXJ *j);
470 static void ixj_write_cid(IXJ *j);
471 static void ixj_write_cid_bit(IXJ *j, int bit);
472 static int set_base_frame(IXJ *j, int size);
473 static int set_play_codec(IXJ *j, int rate);
474 static void set_rec_depth(IXJ *j, int depth);
475 static int ixj_mixer(long val, IXJ *j);
476
477 /************************************************************************
478 CT8020/CT8021 Host Programmers Model
479 Host address Function Access
480 DSPbase +
481 0-1 Aux Software Status Register (reserved) Read Only
482 2-3 Software Status Register Read Only
483 4-5 Aux Software Control Register (reserved) Read Write
484 6-7 Software Control Register Read Write
485 8-9 Hardware Status Register Read Only
486 A-B Hardware Control Register Read Write
487 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
488 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
489 ************************************************************************/
490
491 static inline void ixj_read_HSR(IXJ *j)
492 {
493 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
494 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
495 }
496
497 static inline int IsControlReady(IXJ *j)
498 {
499 ixj_read_HSR(j);
500 return j->hsr.bits.controlrdy ? 1 : 0;
501 }
502
503 static inline int IsPCControlReady(IXJ *j)
504 {
505 j->pccr1.byte = inb_p(j->XILINXbase + 3);
506 return j->pccr1.bits.crr ? 1 : 0;
507 }
508
509 static inline int IsStatusReady(IXJ *j)
510 {
511 ixj_read_HSR(j);
512 return j->hsr.bits.statusrdy ? 1 : 0;
513 }
514
515 static inline int IsRxReady(IXJ *j)
516 {
517 ixj_read_HSR(j);
518 ixj_perfmon(j->rxreadycheck);
519 return j->hsr.bits.rxrdy ? 1 : 0;
520 }
521
522 static inline int IsTxReady(IXJ *j)
523 {
524 ixj_read_HSR(j);
525 ixj_perfmon(j->txreadycheck);
526 return j->hsr.bits.txrdy ? 1 : 0;
527 }
528
529 static inline void set_play_volume(IXJ *j, int volume)
530 {
531 if (ixjdebug & 0x0002)
532 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
533 ixj_WriteDSPCommand(0xCF02, j);
534 ixj_WriteDSPCommand(volume, j);
535 }
536
537 static int set_play_volume_linear(IXJ *j, int volume)
538 {
539 int newvolume, dspplaymax;
540
541 if (ixjdebug & 0x0002)
542 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
543 if(volume > 100 || volume < 0) {
544 return -1;
545 }
546
547 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
548 switch (j->cardtype) {
549 case QTI_PHONEJACK:
550 dspplaymax = 0x380;
551 break;
552 case QTI_LINEJACK:
553 if(j->port == PORT_PSTN) {
554 dspplaymax = 0x48;
555 } else {
556 dspplaymax = 0x100;
557 }
558 break;
559 case QTI_PHONEJACK_LITE:
560 dspplaymax = 0x380;
561 break;
562 case QTI_PHONEJACK_PCI:
563 dspplaymax = 0x6C;
564 break;
565 case QTI_PHONECARD:
566 dspplaymax = 0x50;
567 break;
568 default:
569 return -1;
570 }
571 newvolume = (dspplaymax * volume) / 100;
572 set_play_volume(j, newvolume);
573 return 0;
574 }
575
576 static inline void set_play_depth(IXJ *j, int depth)
577 {
578 if (depth > 60)
579 depth = 60;
580 if (depth < 0)
581 depth = 0;
582 ixj_WriteDSPCommand(0x5280 + depth, j);
583 }
584
585 static inline int get_play_volume(IXJ *j)
586 {
587 ixj_WriteDSPCommand(0xCF00, j);
588 return j->ssr.high << 8 | j->ssr.low;
589 }
590
591 static int get_play_volume_linear(IXJ *j)
592 {
593 int volume, newvolume, dspplaymax;
594
595 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
596 switch (j->cardtype) {
597 case QTI_PHONEJACK:
598 dspplaymax = 0x380;
599 break;
600 case QTI_LINEJACK:
601 if(j->port == PORT_PSTN) {
602 dspplaymax = 0x48;
603 } else {
604 dspplaymax = 0x100;
605 }
606 break;
607 case QTI_PHONEJACK_LITE:
608 dspplaymax = 0x380;
609 break;
610 case QTI_PHONEJACK_PCI:
611 dspplaymax = 0x6C;
612 break;
613 case QTI_PHONECARD:
614 dspplaymax = 100;
615 break;
616 default:
617 return -1;
618 }
619 volume = get_play_volume(j);
620 newvolume = (volume * 100) / dspplaymax;
621 if(newvolume > 100)
622 newvolume = 100;
623 return newvolume;
624 }
625
626 static inline BYTE SLIC_GetState(IXJ *j)
627 {
628 if (j->cardtype == QTI_PHONECARD) {
629 j->pccr1.byte = 0;
630 j->psccr.bits.dev = 3;
631 j->psccr.bits.rw = 1;
632 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
633 ixj_PCcontrol_wait(j);
634 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
635 ixj_PCcontrol_wait(j);
636 if (j->pslic.bits.powerdown)
637 return PLD_SLIC_STATE_OC;
638 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
639 return PLD_SLIC_STATE_ACTIVE;
640 else
641 return PLD_SLIC_STATE_RINGING;
642 } else {
643 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
644 }
645 return j->pld_slicr.bits.state;
646 }
647
648 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
649 {
650 BOOL fRetVal = FALSE;
651
652 if (j->cardtype == QTI_PHONECARD) {
653 if (j->flags.pcmciasct) {
654 switch (byState) {
655 case PLD_SLIC_STATE_TIPOPEN:
656 case PLD_SLIC_STATE_OC:
657 j->pslic.bits.powerdown = 1;
658 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
659 fRetVal = TRUE;
660 break;
661 case PLD_SLIC_STATE_RINGING:
662 if (j->readers || j->writers) {
663 j->pslic.bits.powerdown = 0;
664 j->pslic.bits.ring0 = 1;
665 j->pslic.bits.ring1 = 0;
666 fRetVal = TRUE;
667 }
668 break;
669 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
670
671 case PLD_SLIC_STATE_STANDBY:
672 case PLD_SLIC_STATE_ACTIVE:
673 if (j->readers || j->writers) {
674 j->pslic.bits.powerdown = 0;
675 } else {
676 j->pslic.bits.powerdown = 1;
677 }
678 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
679 fRetVal = TRUE;
680 break;
681 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
682
683 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
684
685 default:
686 fRetVal = FALSE;
687 break;
688 }
689 j->psccr.bits.dev = 3;
690 j->psccr.bits.rw = 0;
691 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
692 ixj_PCcontrol_wait(j);
693 }
694 } else {
695 /* Set the C1, C2, C3 & B2EN signals. */
696 switch (byState) {
697 case PLD_SLIC_STATE_OC:
698 j->pld_slicw.bits.c1 = 0;
699 j->pld_slicw.bits.c2 = 0;
700 j->pld_slicw.bits.c3 = 0;
701 j->pld_slicw.bits.b2en = 0;
702 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
703 fRetVal = TRUE;
704 break;
705 case PLD_SLIC_STATE_RINGING:
706 j->pld_slicw.bits.c1 = 1;
707 j->pld_slicw.bits.c2 = 0;
708 j->pld_slicw.bits.c3 = 0;
709 j->pld_slicw.bits.b2en = 1;
710 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
711 fRetVal = TRUE;
712 break;
713 case PLD_SLIC_STATE_ACTIVE:
714 j->pld_slicw.bits.c1 = 0;
715 j->pld_slicw.bits.c2 = 1;
716 j->pld_slicw.bits.c3 = 0;
717 j->pld_slicw.bits.b2en = 0;
718 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
719 fRetVal = TRUE;
720 break;
721 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
722
723 j->pld_slicw.bits.c1 = 1;
724 j->pld_slicw.bits.c2 = 1;
725 j->pld_slicw.bits.c3 = 0;
726 j->pld_slicw.bits.b2en = 0;
727 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
728 fRetVal = TRUE;
729 break;
730 case PLD_SLIC_STATE_TIPOPEN:
731 j->pld_slicw.bits.c1 = 0;
732 j->pld_slicw.bits.c2 = 0;
733 j->pld_slicw.bits.c3 = 1;
734 j->pld_slicw.bits.b2en = 0;
735 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
736 fRetVal = TRUE;
737 break;
738 case PLD_SLIC_STATE_STANDBY:
739 j->pld_slicw.bits.c1 = 1;
740 j->pld_slicw.bits.c2 = 0;
741 j->pld_slicw.bits.c3 = 1;
742 j->pld_slicw.bits.b2en = 1;
743 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
744 fRetVal = TRUE;
745 break;
746 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
747
748 j->pld_slicw.bits.c1 = 0;
749 j->pld_slicw.bits.c2 = 1;
750 j->pld_slicw.bits.c3 = 1;
751 j->pld_slicw.bits.b2en = 0;
752 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
753 fRetVal = TRUE;
754 break;
755 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
756
757 j->pld_slicw.bits.c1 = 1;
758 j->pld_slicw.bits.c2 = 1;
759 j->pld_slicw.bits.c3 = 1;
760 j->pld_slicw.bits.b2en = 0;
761 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
762 fRetVal = TRUE;
763 break;
764 default:
765 fRetVal = FALSE;
766 break;
767 }
768 }
769
770 return fRetVal;
771 }
772
773 static int ixj_wink(IXJ *j)
774 {
775 BYTE slicnow;
776
777 slicnow = SLIC_GetState(j);
778
779 j->pots_winkstart = jiffies;
780 SLIC_SetState(PLD_SLIC_STATE_OC, j);
781
782 while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
783 set_current_state(TASK_INTERRUPTIBLE);
784 schedule_timeout(1);
785 }
786
787 SLIC_SetState(slicnow, j);
788 return 0;
789 }
790
791 static void ixj_init_timer(IXJ *j)
792 {
793 init_timer(&j->timer);
794 j->timer.function = ixj_timeout;
795 j->timer.data = (unsigned long)j;
796 }
797
798 static void ixj_add_timer(IXJ *j)
799 {
800 j->timer.expires = jiffies + (hertz / samplerate);
801 add_timer(&j->timer);
802 }
803
804 static void ixj_tone_timeout(IXJ *j)
805 {
806 IXJ_TONE ti;
807
808 j->tone_state++;
809 if (j->tone_state == 3) {
810 j->tone_state = 0;
811 if (j->cadence_t) {
812 j->tone_cadence_state++;
813 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
814 switch (j->cadence_t->termination) {
815 case PLAY_ONCE:
816 ixj_cpt_stop(j);
817 break;
818 case REPEAT_LAST_ELEMENT:
819 j->tone_cadence_state--;
820 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
821 break;
822 case REPEAT_ALL:
823 j->tone_cadence_state = 0;
824 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
825 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
826 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
827 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
828 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
829 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
830 ixj_init_tone(j, &ti);
831 }
832 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
833 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
834 ixj_play_tone(j, j->cadence_t->ce[0].index);
835 break;
836 }
837 } else {
838 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
839 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
840 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
841 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
842 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
843 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
844 ixj_init_tone(j, &ti);
845 }
846 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
847 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
848 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
849 }
850 }
851 }
852 }
853
854 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
855 {
856 if(j->ixj_signals[event]) {
857 if(ixjdebug & 0x0100)
858 printk("Sending signal for event %d\n", event);
859 /* Send apps notice of change */
860 /* see config.h for macro definition */
861 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
862 }
863 }
864
865 static void ixj_pstn_state(IXJ *j)
866 {
867 int var;
868 union XOPXR0 XR0, daaint;
869
870 var = 10;
871
872 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
873 daaint.reg = 0;
874 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
875
876 j->pld_scrr.byte = inb_p(j->XILINXbase);
877 if (j->pld_scrr.bits.daaflag) {
878 daa_int_read(j);
879 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
880 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
881 daaint.bitreg.RING = 1;
882 if(ixjdebug & 0x0008) {
883 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
884 }
885 } else {
886 daa_set_mode(j, SOP_PU_RESET);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
890 daaint.bitreg.Caller_ID = 1;
891 j->pstn_cid_intr = 1;
892 j->pstn_cid_received = jiffies;
893 if(ixjdebug & 0x0008) {
894 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
895 }
896 }
897 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
898 daaint.bitreg.Cadence = 1;
899 if(ixjdebug & 0x0008) {
900 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
901 }
902 }
903 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
904 daaint.bitreg.VDD_OK = 1;
905 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
906 }
907 }
908 daa_CR_read(j, 1);
909 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
910 daaint.bitreg.RMR = 1;
911 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
912 if(ixjdebug & 0x0008) {
913 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
914 }
915 j->pstn_prev_rmr = j->pstn_last_rmr;
916 j->pstn_last_rmr = jiffies;
917 }
918 switch(j->daa_mode) {
919 case SOP_PU_SLEEP:
920 if (daaint.bitreg.RING) {
921 if (!j->flags.pstn_ringing) {
922 if (j->daa_mode != SOP_PU_RINGING) {
923 j->pstn_ring_int = jiffies;
924 daa_set_mode(j, SOP_PU_RINGING);
925 }
926 }
927 }
928 break;
929 case SOP_PU_RINGING:
930 if (daaint.bitreg.RMR) {
931 if (ixjdebug & 0x0008) {
932 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
933 }
934 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
935 j->flags.pstn_rmr = 1;
936 j->pstn_ring_start = jiffies;
937 j->pstn_ring_stop = 0;
938 j->ex.bits.pstn_ring = 0;
939 if (j->cadence_f[4].state == 0) {
940 j->cadence_f[4].state = 1;
941 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
942 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
943 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
944 } else if (j->cadence_f[4].state == 2) {
945 if((time_after(jiffies, j->cadence_f[4].off1min) &&
946 time_before(jiffies, j->cadence_f[4].off1max))) {
947 if (j->cadence_f[4].on2) {
948 j->cadence_f[4].state = 3;
949 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
950 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
951 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
952 } else {
953 j->cadence_f[4].state = 7;
954 }
955 } else {
956 if (ixjdebug & 0x0008) {
957 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
958 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
959 j->cadence_f[4].off1);
960 }
961 j->cadence_f[4].state = 0;
962 }
963 } else if (j->cadence_f[4].state == 4) {
964 if((time_after(jiffies, j->cadence_f[4].off2min) &&
965 time_before(jiffies, j->cadence_f[4].off2max))) {
966 if (j->cadence_f[4].on3) {
967 j->cadence_f[4].state = 5;
968 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
969 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
970 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
971 } else {
972 j->cadence_f[4].state = 7;
973 }
974 } else {
975 if (ixjdebug & 0x0008) {
976 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
977 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
978 j->cadence_f[4].off2);
979 }
980 j->cadence_f[4].state = 0;
981 }
982 } else if (j->cadence_f[4].state == 6) {
983 if((time_after(jiffies, j->cadence_f[4].off3min) &&
984 time_before(jiffies, j->cadence_f[4].off3max))) {
985 j->cadence_f[4].state = 7;
986 } else {
987 if (ixjdebug & 0x0008) {
988 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
989 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
990 j->cadence_f[4].off3);
991 }
992 j->cadence_f[4].state = 0;
993 }
994 } else {
995 j->cadence_f[4].state = 0;
996 }
997 } else { /* Falling edge of RMR */
998 j->pstn_ring_start = 0;
999 j->pstn_ring_stop = jiffies;
1000 if (j->cadence_f[4].state == 1) {
1001 if(!j->cadence_f[4].on1) {
1002 j->cadence_f[4].state = 7;
1003 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004 time_before(jiffies, j->cadence_f[4].on1max))) {
1005 if (j->cadence_f[4].off1) {
1006 j->cadence_f[4].state = 2;
1007 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010 } else {
1011 j->cadence_f[4].state = 7;
1012 }
1013 } else {
1014 if (ixjdebug & 0x0008) {
1015 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017 j->cadence_f[4].on1);
1018 }
1019 j->cadence_f[4].state = 0;
1020 }
1021 } else if (j->cadence_f[4].state == 3) {
1022 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023 time_before(jiffies, j->cadence_f[4].on2max))) {
1024 if (j->cadence_f[4].off2) {
1025 j->cadence_f[4].state = 4;
1026 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029 } else {
1030 j->cadence_f[4].state = 7;
1031 }
1032 } else {
1033 if (ixjdebug & 0x0008) {
1034 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036 j->cadence_f[4].on2);
1037 }
1038 j->cadence_f[4].state = 0;
1039 }
1040 } else if (j->cadence_f[4].state == 5) {
1041 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042 time_before(jiffies, j->cadence_f[4].on3max))) {
1043 if (j->cadence_f[4].off3) {
1044 j->cadence_f[4].state = 6;
1045 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048 } else {
1049 j->cadence_f[4].state = 7;
1050 }
1051 } else {
1052 j->cadence_f[4].state = 0;
1053 }
1054 } else {
1055 if (ixjdebug & 0x0008) {
1056 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058 j->cadence_f[4].on3);
1059 }
1060 j->cadence_f[4].state = 0;
1061 }
1062 }
1063 if (ixjdebug & 0x0010) {
1064 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065 }
1066 if (ixjdebug & 0x0010) {
1067 switch(j->cadence_f[4].state) {
1068 case 1:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071 break;
1072 case 2:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075 break;
1076 case 3:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079 break;
1080 case 4:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083 break;
1084 case 5:
1085 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087 break;
1088 case 6:
1089 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091 break;
1092 }
1093 }
1094 }
1095 if (j->cadence_f[4].state == 7) {
1096 j->cadence_f[4].state = 0;
1097 j->pstn_ring_stop = jiffies;
1098 j->ex.bits.pstn_ring = 1;
1099 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100 if(ixjdebug & 0x0008) {
1101 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102 }
1103 }
1104 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106 if(ixjdebug & 0x0008) {
1107 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110 }
1111 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112 daa_set_mode(j, SOP_PU_SLEEP);
1113 }
1114 outb_p(j->pld_scrw.byte, j->XILINXbase);
1115 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116 ixj_daa_cid_read(j);
1117 j->ex.bits.caller_id = 1;
1118 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119 j->pstn_cid_intr = 0;
1120 }
1121 if (daaint.bitreg.Cadence) {
1122 if(ixjdebug & 0x0008) {
1123 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124 }
1125 daa_set_mode(j, SOP_PU_SLEEP);
1126 j->ex.bits.pstn_ring = 0;
1127 }
1128 break;
1129 case SOP_PU_CONVERSATION:
1130 if (daaint.bitreg.VDD_OK) {
1131 if(!daaint.bitreg.SI_0) {
1132 if (!j->pstn_winkstart) {
1133 if(ixjdebug & 0x0008) {
1134 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135 }
1136 j->pstn_winkstart = jiffies;
1137 }
1138 } else {
1139 if (j->pstn_winkstart) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 j->pstn_winkstart = 0;
1144 }
1145 }
1146 }
1147 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148 if(ixjdebug & 0x0008) {
1149 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150 }
1151 daa_set_mode(j, SOP_PU_SLEEP);
1152 j->pstn_winkstart = 0;
1153 j->ex.bits.pstn_wink = 1;
1154 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155 }
1156 break;
1157 }
1158 }
1159
1160 static void ixj_timeout(unsigned long ptr)
1161 {
1162 int board;
1163 unsigned long jifon;
1164 IXJ *j = (IXJ *)ptr;
1165 board = j->board;
1166
1167 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168 ixj_perfmon(j->timerchecks);
1169 j->hookstate = ixj_hookstate(j);
1170 if (j->tone_state) {
1171 if (!(j->hookstate)) {
1172 ixj_cpt_stop(j);
1173 if (j->m_hook) {
1174 j->m_hook = 0;
1175 j->ex.bits.hookstate = 1;
1176 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177 }
1178 clear_bit(board, &j->busyflags);
1179 ixj_add_timer(j);
1180 return;
1181 }
1182 if (j->tone_state == 1)
1183 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184 else
1185 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187 if (j->tone_state == 1) {
1188 ixj_play_tone(j, j->tone_index);
1189 if (j->dsp.low == 0x20) {
1190 clear_bit(board, &j->busyflags);
1191 ixj_add_timer(j);
1192 return;
1193 }
1194 } else {
1195 ixj_play_tone(j, 0);
1196 if (j->dsp.low == 0x20) {
1197 clear_bit(board, &j->busyflags);
1198 ixj_add_timer(j);
1199 return;
1200 }
1201 }
1202 } else {
1203 ixj_tone_timeout(j);
1204 if (j->flags.dialtone) {
1205 ixj_dialtone(j);
1206 }
1207 if (j->flags.busytone) {
1208 ixj_busytone(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (j->flags.ringback) {
1216 ixj_ringback(j);
1217 if (j->dsp.low == 0x20) {
1218 clear_bit(board, &j->busyflags);
1219 ixj_add_timer(j);
1220 return;
1221 }
1222 }
1223 if (!j->tone_state) {
1224 ixj_cpt_stop(j);
1225 }
1226 }
1227 }
1228 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229 if (IsRxReady(j)) {
1230 ixj_read_frame(j);
1231 }
1232 if (IsTxReady(j)) {
1233 ixj_write_frame(j);
1234 }
1235 }
1236 if (j->flags.cringing) {
1237 if (j->hookstate & 1) {
1238 j->flags.cringing = 0;
1239 ixj_ring_off(j);
1240 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241 switch(j->cadence_f[5].state) {
1242 case 0:
1243 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245 if(ixjdebug & 0x0004) {
1246 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247 }
1248 ixj_ring_on(j);
1249 }
1250 j->cadence_f[5].state = 1;
1251 break;
1252 case 1:
1253 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255 if(ixjdebug & 0x0004) {
1256 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257 }
1258 ixj_ring_off(j);
1259 j->cadence_f[5].state = 2;
1260 }
1261 break;
1262 case 2:
1263 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264 if(ixjdebug & 0x0004) {
1265 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266 }
1267 ixj_ring_on(j);
1268 if (j->cadence_f[5].on2) {
1269 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270 j->cadence_f[5].state = 3;
1271 } else {
1272 j->cadence_f[5].state = 7;
1273 }
1274 }
1275 break;
1276 case 3:
1277 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278 if(ixjdebug & 0x0004) {
1279 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280 }
1281 ixj_ring_off(j);
1282 if (j->cadence_f[5].off2) {
1283 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284 j->cadence_f[5].state = 4;
1285 } else {
1286 j->cadence_f[5].state = 7;
1287 }
1288 }
1289 break;
1290 case 4:
1291 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292 if(ixjdebug & 0x0004) {
1293 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294 }
1295 ixj_ring_on(j);
1296 if (j->cadence_f[5].on3) {
1297 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298 j->cadence_f[5].state = 5;
1299 } else {
1300 j->cadence_f[5].state = 7;
1301 }
1302 }
1303 break;
1304 case 5:
1305 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306 if(ixjdebug & 0x0004) {
1307 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308 }
1309 ixj_ring_off(j);
1310 if (j->cadence_f[5].off3) {
1311 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312 j->cadence_f[5].state = 6;
1313 } else {
1314 j->cadence_f[5].state = 7;
1315 }
1316 }
1317 break;
1318 case 6:
1319 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320 if(ixjdebug & 0x0004) {
1321 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322 }
1323 j->cadence_f[5].state = 7;
1324 }
1325 break;
1326 case 7:
1327 if(ixjdebug & 0x0004) {
1328 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329 }
1330 j->flags.cidring = 1;
1331 j->cadence_f[5].state = 0;
1332 break;
1333 }
1334 if (j->flags.cidring && !j->flags.cidsent) {
1335 j->flags.cidsent = 1;
1336 if(j->fskdcnt) {
1337 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338 ixj_pre_cid(j);
1339 }
1340 j->flags.cidring = 0;
1341 }
1342 clear_bit(board, &j->busyflags);
1343 ixj_add_timer(j);
1344 return;
1345 } else {
1346 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347 if (j->flags.cidring && !j->flags.cidsent) {
1348 j->flags.cidsent = 1;
1349 if(j->fskdcnt) {
1350 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351 ixj_pre_cid(j);
1352 }
1353 j->flags.cidring = 0;
1354 }
1355 j->ring_cadence_t--;
1356 if (j->ring_cadence_t == -1)
1357 j->ring_cadence_t = 15;
1358 j->ring_cadence_jif = jiffies;
1359
1360 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362 j->flags.firstring = 1;
1363 else
1364 ixj_ring_on(j);
1365 } else {
1366 ixj_ring_off(j);
1367 if(!j->flags.cidsent)
1368 j->flags.cidring = 1;
1369 }
1370 }
1371 clear_bit(board, &j->busyflags);
1372 ixj_add_timer(j);
1373 return;
1374 }
1375 }
1376 if (!j->flags.ringing) {
1377 if (j->hookstate) { /* & 1) { */
1378 if (j->dsp.low != 0x20 &&
1379 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381 }
1382 LineMonitor(j);
1383 read_filters(j);
1384 ixj_WriteDSPCommand(0x511B, j);
1385 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386 if (!j->m_hook && (j->hookstate & 1)) {
1387 j->m_hook = j->ex.bits.hookstate = 1;
1388 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389 }
1390 } else {
1391 if (j->ex.bits.dtmf_ready) {
1392 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393 }
1394 if (j->m_hook) {
1395 j->m_hook = 0;
1396 j->ex.bits.hookstate = 1;
1397 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398 }
1399 }
1400 }
1401 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402 ixj_pstn_state(j);
1403 }
1404 if (j->ex.bytes) {
1405 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1406 }
1407 clear_bit(board, &j->busyflags);
1408 }
1409 ixj_add_timer(j);
1410 }
1411
1412 static int ixj_status_wait(IXJ *j)
1413 {
1414 unsigned long jif;
1415
1416 jif = jiffies + ((60 * hertz) / 100);
1417 while (!IsStatusReady(j)) {
1418 ixj_perfmon(j->statuswait);
1419 if (time_after(jiffies, jif)) {
1420 ixj_perfmon(j->statuswaitfail);
1421 return -1;
1422 }
1423 }
1424 return 0;
1425 }
1426
1427 static int ixj_PCcontrol_wait(IXJ *j)
1428 {
1429 unsigned long jif;
1430
1431 jif = jiffies + ((60 * hertz) / 100);
1432 while (!IsPCControlReady(j)) {
1433 ixj_perfmon(j->pcontrolwait);
1434 if (time_after(jiffies, jif)) {
1435 ixj_perfmon(j->pcontrolwaitfail);
1436 return -1;
1437 }
1438 }
1439 return 0;
1440 }
1441
1442 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443 {
1444 BYTES bytes;
1445 unsigned long jif;
1446
1447 atomic_inc(&j->DSPWrite);
1448 if(atomic_read(&j->DSPWrite) > 1) {
1449 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450 return -1;
1451 }
1452 bytes.high = (cmd & 0xFF00) >> 8;
1453 bytes.low = cmd & 0x00FF;
1454 jif = jiffies + ((60 * hertz) / 100);
1455 while (!IsControlReady(j)) {
1456 ixj_perfmon(j->iscontrolready);
1457 if (time_after(jiffies, jif)) {
1458 ixj_perfmon(j->iscontrolreadyfail);
1459 atomic_dec(&j->DSPWrite);
1460 if(atomic_read(&j->DSPWrite) > 0) {
1461 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462 while(atomic_read(&j->DSPWrite) > 0) {
1463 atomic_dec(&j->DSPWrite);
1464 }
1465 }
1466 return -1;
1467 }
1468 }
1469 outb(bytes.low, j->DSPbase + 6);
1470 outb(bytes.high, j->DSPbase + 7);
1471
1472 if (ixj_status_wait(j)) {
1473 j->ssr.low = 0xFF;
1474 j->ssr.high = 0xFF;
1475 atomic_dec(&j->DSPWrite);
1476 if(atomic_read(&j->DSPWrite) > 0) {
1477 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478 while(atomic_read(&j->DSPWrite) > 0) {
1479 atomic_dec(&j->DSPWrite);
1480 }
1481 }
1482 return -1;
1483 }
1484 /* Read Software Status Register */
1485 j->ssr.low = inb_p(j->DSPbase + 2);
1486 j->ssr.high = inb_p(j->DSPbase + 3);
1487 atomic_dec(&j->DSPWrite);
1488 if(atomic_read(&j->DSPWrite) > 0) {
1489 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490 while(atomic_read(&j->DSPWrite) > 0) {
1491 atomic_dec(&j->DSPWrite);
1492 }
1493 }
1494 return 0;
1495 }
1496
1497 /***************************************************************************
1498 *
1499 * General Purpose IO Register read routine
1500 *
1501 ***************************************************************************/
1502 static inline int ixj_gpio_read(IXJ *j)
1503 {
1504 if (ixj_WriteDSPCommand(0x5143, j))
1505 return -1;
1506
1507 j->gpio.bytes.low = j->ssr.low;
1508 j->gpio.bytes.high = j->ssr.high;
1509
1510 return 0;
1511 }
1512
1513 static inline void LED_SetState(int state, IXJ *j)
1514 {
1515 if (j->cardtype == QTI_LINEJACK) {
1516 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521 outb(j->pld_scrw.byte, j->XILINXbase);
1522 }
1523 }
1524
1525 /*********************************************************************
1526 * GPIO Pins are configured as follows on the Quicknet Internet
1527 * PhoneJACK Telephony Cards
1528 *
1529 * POTS Select GPIO_6=0 GPIO_7=0
1530 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531 * Handset Select GPIO_6=1 GPIO_7=0
1532 *
1533 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1534 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1535 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1536 *
1537 * Hook Switch changes reported on GPIO_3
1538 *********************************************************************/
1539 static int ixj_set_port(IXJ *j, int arg)
1540 {
1541 if (j->cardtype == QTI_PHONEJACK_LITE) {
1542 if (arg != PORT_POTS)
1543 return 10;
1544 else
1545 return 0;
1546 }
1547 switch (arg) {
1548 case PORT_POTS:
1549 j->port = PORT_POTS;
1550 switch (j->cardtype) {
1551 case QTI_PHONECARD:
1552 if (j->flags.pcmciasct == 1)
1553 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554 else
1555 return 11;
1556 break;
1557 case QTI_PHONEJACK_PCI:
1558 j->pld_slicw.pcib.mic = 0;
1559 j->pld_slicw.pcib.spk = 0;
1560 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561 break;
1562 case QTI_LINEJACK:
1563 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1564 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1565 Software Control Register */
1566 return 2;
1567 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1568
1569 outb(j->pld_scrw.byte, j->XILINXbase);
1570 j->pld_clock.byte = 0;
1571 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572 j->pld_slicw.bits.rly1 = 1;
1573 j->pld_slicw.bits.spken = 0;
1574 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1576 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1577 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1578 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1579 ixj_mixer(0x0E80, j); /*Mic mute */
1580 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1581 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1582 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1583 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585 break;
1586 case QTI_PHONEJACK:
1587 j->gpio.bytes.high = 0x0B;
1588 j->gpio.bits.gpio6 = 0;
1589 j->gpio.bits.gpio7 = 0;
1590 ixj_WriteDSPCommand(j->gpio.word, j);
1591 break;
1592 }
1593 break;
1594 case PORT_PSTN:
1595 if (j->cardtype == QTI_LINEJACK) {
1596 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598 j->pld_slicw.bits.rly3 = 0;
1599 j->pld_slicw.bits.rly1 = 1;
1600 j->pld_slicw.bits.spken = 0;
1601 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602 j->port = PORT_PSTN;
1603 } else {
1604 return 4;
1605 }
1606 break;
1607 case PORT_SPEAKER:
1608 j->port = PORT_SPEAKER;
1609 switch (j->cardtype) {
1610 case QTI_PHONECARD:
1611 if (j->flags.pcmciasct) {
1612 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613 }
1614 break;
1615 case QTI_PHONEJACK_PCI:
1616 j->pld_slicw.pcib.mic = 1;
1617 j->pld_slicw.pcib.spk = 1;
1618 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619 break;
1620 case QTI_LINEJACK:
1621 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1622 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1623 Software Control Register */
1624 return 2;
1625 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1626
1627 outb(j->pld_scrw.byte, j->XILINXbase);
1628 j->pld_clock.byte = 0;
1629 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630 j->pld_slicw.bits.rly1 = 1;
1631 j->pld_slicw.bits.spken = 1;
1632 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1634 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1635 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1636 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1637 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1638 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1639 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1640 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1641 break;
1642 case QTI_PHONEJACK:
1643 j->gpio.bytes.high = 0x0B;
1644 j->gpio.bits.gpio6 = 0;
1645 j->gpio.bits.gpio7 = 1;
1646 ixj_WriteDSPCommand(j->gpio.word, j);
1647 break;
1648 }
1649 break;
1650 case PORT_HANDSET:
1651 if (j->cardtype != QTI_PHONEJACK) {
1652 return 5;
1653 } else {
1654 j->gpio.bytes.high = 0x0B;
1655 j->gpio.bits.gpio6 = 1;
1656 j->gpio.bits.gpio7 = 0;
1657 ixj_WriteDSPCommand(j->gpio.word, j);
1658 j->port = PORT_HANDSET;
1659 }
1660 break;
1661 default:
1662 return 6;
1663 break;
1664 }
1665 return 0;
1666 }
1667
1668 static int ixj_set_pots(IXJ *j, int arg)
1669 {
1670 if (j->cardtype == QTI_LINEJACK) {
1671 if (arg) {
1672 if (j->port == PORT_PSTN) {
1673 j->pld_slicw.bits.rly1 = 0;
1674 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675 j->flags.pots_pstn = 1;
1676 return 1;
1677 } else {
1678 j->flags.pots_pstn = 0;
1679 return 0;
1680 }
1681 } else {
1682 j->pld_slicw.bits.rly1 = 1;
1683 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684 j->flags.pots_pstn = 0;
1685 return 1;
1686 }
1687 } else {
1688 return 0;
1689 }
1690 }
1691
1692 static void ixj_ring_on(IXJ *j)
1693 {
1694 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695 {
1696 if (ixjdebug & 0x0004)
1697 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1698
1699 j->gpio.bytes.high = 0x0B;
1700 j->gpio.bytes.low = 0x00;
1701 j->gpio.bits.gpio1 = 1;
1702 j->gpio.bits.gpio2 = 1;
1703 j->gpio.bits.gpio5 = 0;
1704 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1705 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706 {
1707 if (ixjdebug & 0x0004)
1708 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711 }
1712 }
1713
1714 static int ixj_siadc(IXJ *j, int val)
1715 {
1716 if(j->cardtype == QTI_PHONECARD){
1717 if(j->flags.pcmciascp){
1718 if(val == -1)
1719 return j->siadc.bits.rxg;
1720
1721 if(val < 0 || val > 0x1F)
1722 return -1;
1723
1724 j->siadc.bits.hom = 0; /* Handset Out Mute */
1725 j->siadc.bits.lom = 0; /* Line Out Mute */
1726 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1727 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1728 j->psccr.bits.rw = 0; /* Read / Write flag */
1729 j->psccr.bits.dev = 0;
1730 outb(j->siadc.byte, j->XILINXbase + 0x00);
1731 outb(j->psccr.byte, j->XILINXbase + 0x01);
1732 ixj_PCcontrol_wait(j);
1733 return j->siadc.bits.rxg;
1734 }
1735 }
1736 return -1;
1737 }
1738
1739 static int ixj_sidac(IXJ *j, int val)
1740 {
1741 if(j->cardtype == QTI_PHONECARD){
1742 if(j->flags.pcmciascp){
1743 if(val == -1)
1744 return j->sidac.bits.txg;
1745
1746 if(val < 0 || val > 0x1F)
1747 return -1;
1748
1749 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1750 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1751 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1752 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1753 j->psccr.bits.rw = 0; /* Read / Write flag */
1754 j->psccr.bits.dev = 0;
1755 outb(j->sidac.byte, j->XILINXbase + 0x00);
1756 outb(j->psccr.byte, j->XILINXbase + 0x01);
1757 ixj_PCcontrol_wait(j);
1758 return j->sidac.bits.txg;
1759 }
1760 }
1761 return -1;
1762 }
1763
1764 static int ixj_pcmcia_cable_check(IXJ *j)
1765 {
1766 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767 if (!j->flags.pcmciastate) {
1768 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770 j->flags.pcmciastate = 4;
1771 return 0;
1772 }
1773 if (j->pccr1.bits.ed) {
1774 j->pccr1.bits.ed = 0;
1775 j->psccr.bits.dev = 3;
1776 j->psccr.bits.rw = 1;
1777 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778 ixj_PCcontrol_wait(j);
1779 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781 j->psccr.bits.dev = 3;
1782 j->psccr.bits.rw = 0;
1783 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784 ixj_PCcontrol_wait(j);
1785 return j->pslic.bits.led2 ? 1 : 0;
1786 } else if (j->flags.pcmciasct) {
1787 return j->r_hook;
1788 } else {
1789 return 1;
1790 }
1791 } else if (j->flags.pcmciastate == 4) {
1792 if (!j->pccr1.bits.drf) {
1793 j->flags.pcmciastate = 3;
1794 }
1795 return 0;
1796 } else if (j->flags.pcmciastate == 3) {
1797 j->pccr2.bits.pwr = 0;
1798 j->pccr2.bits.rstc = 1;
1799 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800 j->checkwait = jiffies + (hertz * 2);
1801 j->flags.incheck = 1;
1802 j->flags.pcmciastate = 2;
1803 return 0;
1804 } else if (j->flags.pcmciastate == 2) {
1805 if (j->flags.incheck) {
1806 if (time_before(jiffies, j->checkwait)) {
1807 return 0;
1808 } else {
1809 j->flags.incheck = 0;
1810 }
1811 }
1812 j->pccr2.bits.pwr = 0;
1813 j->pccr2.bits.rstc = 0;
1814 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815 j->flags.pcmciastate = 1;
1816 return 0;
1817 } else if (j->flags.pcmciastate == 1) {
1818 j->flags.pcmciastate = 0;
1819 if (!j->pccr1.bits.drf) {
1820 j->psccr.bits.dev = 3;
1821 j->psccr.bits.rw = 1;
1822 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823 ixj_PCcontrol_wait(j);
1824 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1825
1826 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1827
1828 if (j->flags.pcmciasct == 3) {
1829 j->flags.pcmciastate = 4;
1830 return 0;
1831 } else if (j->flags.pcmciasct == 0) {
1832 j->pccr2.bits.pwr = 1;
1833 j->pccr2.bits.rstc = 0;
1834 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835 j->port = PORT_SPEAKER;
1836 } else {
1837 j->port = PORT_POTS;
1838 }
1839 j->sic1.bits.cpd = 0; /* Chip Power Down */
1840 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1841 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1842 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1843 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1844 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1845 j->psccr.bits.rw = 0; /* Read / Write flag */
1846 j->psccr.bits.dev = 0;
1847 outb(j->sic1.byte, j->XILINXbase + 0x00);
1848 outb(j->psccr.byte, j->XILINXbase + 0x01);
1849 ixj_PCcontrol_wait(j);
1850
1851 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1852 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1853 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1854 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1855 j->sic2.bits.hpd = 0; /* HPF disable */
1856 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1857 j->psccr.bits.rw = 0; /* Read / Write flag */
1858 j->psccr.bits.dev = 0;
1859 outb(j->sic2.byte, j->XILINXbase + 0x00);
1860 outb(j->psccr.byte, j->XILINXbase + 0x01);
1861 ixj_PCcontrol_wait(j);
1862
1863 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1864 j->psccr.bits.rw = 0; /* Read / Write flag */
1865 j->psccr.bits.dev = 0;
1866 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1867 outb(j->psccr.byte, j->XILINXbase + 0x01);
1868 ixj_PCcontrol_wait(j);
1869
1870 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1871 j->psccr.bits.rw = 0; /* Read / Write flag */
1872 j->psccr.bits.dev = 0;
1873 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1874 outb(j->psccr.byte, j->XILINXbase + 0x01);
1875 ixj_PCcontrol_wait(j);
1876
1877 j->sirxg.bits.lig = 1; /* Line In Gain */
1878 j->sirxg.bits.lim = 1; /* Line In Mute */
1879 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1880 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1881 j->sirxg.bits.him = 0; /* Handset In Mute */
1882 j->sirxg.bits.iir = 1; /* IIR */
1883 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1884 j->psccr.bits.rw = 0; /* Read / Write flag */
1885 j->psccr.bits.dev = 0;
1886 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887 outb(j->psccr.byte, j->XILINXbase + 0x01);
1888 ixj_PCcontrol_wait(j);
1889
1890 ixj_siadc(j, 0x17);
1891 ixj_sidac(j, 0x1D);
1892
1893 j->siaatt.bits.sot = 0;
1894 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1895 j->psccr.bits.rw = 0; /* Read / Write flag */
1896 j->psccr.bits.dev = 0;
1897 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898 outb(j->psccr.byte, j->XILINXbase + 0x01);
1899 ixj_PCcontrol_wait(j);
1900
1901 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902 j->psccr.byte = j->pslic.byte = 0;
1903 j->pslic.bits.powerdown = 1;
1904 j->psccr.bits.dev = 3;
1905 j->psccr.bits.rw = 0;
1906 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907 ixj_PCcontrol_wait(j);
1908 }
1909 }
1910 return 0;
1911 } else {
1912 j->flags.pcmciascp = 0;
1913 return 0;
1914 }
1915 return 0;
1916 }
1917
1918 static int ixj_hookstate(IXJ *j)
1919 {
1920 unsigned long det;
1921 int fOffHook = 0;
1922
1923 switch (j->cardtype) {
1924 case QTI_PHONEJACK:
1925 ixj_gpio_read(j);
1926 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1927 break;
1928 case QTI_LINEJACK:
1929 case QTI_PHONEJACK_LITE:
1930 case QTI_PHONEJACK_PCI:
1931 SLIC_GetState(j);
1932 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1933 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1934 if(fOffHook != j->p_hook) {
1935 if(!j->checkwait) {
1936 j->checkwait = jiffies;
1937 }
1938 if(time_before(jiffies, j->checkwait + 2)) {
1939 fOffHook ^= 1;
1940 } else {
1941 j->checkwait = 0;
1942 }
1943 j->p_hook = fOffHook;
1944 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1945 }
1946 } else {
1947 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1948 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1949 if (j->flags.ringing || j->flags.cringing) {
1950 if (!in_interrupt()) {
1951 det = jiffies + (hertz / 50);
1952 while (time_before(jiffies, det)) {
1953 set_current_state(TASK_INTERRUPTIBLE);
1954 schedule_timeout(1);
1955 }
1956 }
1957 SLIC_GetState(j);
1958 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1959 ixj_ring_on(j);
1960 }
1961 }
1962 if (j->cardtype == QTI_PHONEJACK_PCI) {
1963 j->pld_scrr.byte = inb_p(j->XILINXbase);
1964 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1965 } else
1966 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1967 }
1968 }
1969 break;
1970 case QTI_PHONECARD:
1971 fOffHook = ixj_pcmcia_cable_check(j);
1972 break;
1973 }
1974 if (j->r_hook != fOffHook) {
1975 j->r_hook = fOffHook;
1976 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1977 j->ex.bits.hookstate = 1;
1978 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1979 } else if (!fOffHook) {
1980 j->flash_end = jiffies + ((60 * hertz) / 100);
1981 }
1982 }
1983 if (fOffHook) {
1984 if(time_before(jiffies, j->flash_end)) {
1985 j->ex.bits.flash = 1;
1986 j->flash_end = 0;
1987 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1988 }
1989 } else {
1990 if(time_before(jiffies, j->flash_end)) {
1991 fOffHook = 1;
1992 }
1993 }
1994
1995 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1996 fOffHook |= 2;
1997
1998 if (j->port == PORT_SPEAKER) {
1999 if(j->cardtype == QTI_PHONECARD) {
2000 if(j->flags.pcmciascp && j->flags.pcmciasct) {
2001 fOffHook |= 2;
2002 }
2003 } else {
2004 fOffHook |= 2;
2005 }
2006 }
2007
2008 if (j->port == PORT_HANDSET)
2009 fOffHook |= 2;
2010
2011 return fOffHook;
2012 }
2013
2014 static void ixj_ring_off(IXJ *j)
2015 {
2016 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2017 {
2018 if (ixjdebug & 0x0004)
2019 printk(KERN_INFO "IXJ Ring Off\n");
2020 j->gpio.bytes.high = 0x0B;
2021 j->gpio.bytes.low = 0x00;
2022 j->gpio.bits.gpio1 = 0;
2023 j->gpio.bits.gpio2 = 1;
2024 j->gpio.bits.gpio5 = 0;
2025 ixj_WriteDSPCommand(j->gpio.word, j);
2026 } else /* Internet LineJACK */
2027 {
2028 if (ixjdebug & 0x0004)
2029 printk(KERN_INFO "IXJ Ring Off\n");
2030
2031 if(!j->flags.cidplay)
2032 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2033
2034 SLIC_GetState(j);
2035 }
2036 }
2037
2038 static void ixj_ring_start(IXJ *j)
2039 {
2040 j->flags.cringing = 1;
2041 if (ixjdebug & 0x0004)
2042 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2043 if (ixj_hookstate(j) & 1) {
2044 if (j->port == PORT_POTS)
2045 ixj_ring_off(j);
2046 j->flags.cringing = 0;
2047 if (ixjdebug & 0x0004)
2048 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2049 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2050 j->ring_cadence_jif = jiffies;
2051 j->flags.cidsent = j->flags.cidring = 0;
2052 j->cadence_f[5].state = 0;
2053 if(j->cadence_f[5].on1)
2054 ixj_ring_on(j);
2055 } else {
2056 j->ring_cadence_jif = jiffies;
2057 j->ring_cadence_t = 15;
2058 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2059 ixj_ring_on(j);
2060 } else {
2061 ixj_ring_off(j);
2062 }
2063 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2064 }
2065 }
2066
2067 static int ixj_ring(IXJ *j)
2068 {
2069 char cntr;
2070 unsigned long jif, det;
2071
2072 j->flags.ringing = 1;
2073 if (ixj_hookstate(j) & 1) {
2074 ixj_ring_off(j);
2075 j->flags.ringing = 0;
2076 return 1;
2077 }
2078 det = 0;
2079 for (cntr = 0; cntr < j->maxrings; cntr++) {
2080 jif = jiffies + (1 * hertz);
2081 ixj_ring_on(j);
2082 while (time_before(jiffies, jif)) {
2083 if (ixj_hookstate(j) & 1) {
2084 ixj_ring_off(j);
2085 j->flags.ringing = 0;
2086 return 1;
2087 }
2088 set_current_state(TASK_INTERRUPTIBLE);
2089 schedule_timeout(1);
2090 if (signal_pending(current))
2091 break;
2092 }
2093 jif = jiffies + (3 * hertz);
2094 ixj_ring_off(j);
2095 while (time_before(jiffies, jif)) {
2096 if (ixj_hookstate(j) & 1) {
2097 det = jiffies + (hertz / 100);
2098 while (time_before(jiffies, det)) {
2099 set_current_state(TASK_INTERRUPTIBLE);
2100 schedule_timeout(1);
2101 if (signal_pending(current))
2102 break;
2103 }
2104 if (ixj_hookstate(j) & 1) {
2105 j->flags.ringing = 0;
2106 return 1;
2107 }
2108 }
2109 set_current_state(TASK_INTERRUPTIBLE);
2110 schedule_timeout(1);
2111 if (signal_pending(current))
2112 break;
2113 }
2114 }
2115 ixj_ring_off(j);
2116 j->flags.ringing = 0;
2117 return 0;
2118 }
2119
2120 static int ixj_open(struct phone_device *p, struct file *file_p)
2121 {
2122 IXJ *j = get_ixj(p->board);
2123 file_p->private_data = j;
2124
2125 if (!j->DSPbase)
2126 return -ENODEV;
2127
2128 if (file_p->f_mode & FMODE_READ) {
2129 if(!j->readers) {
2130 j->readers++;
2131 } else {
2132 return -EBUSY;
2133 }
2134 }
2135
2136 if (file_p->f_mode & FMODE_WRITE) {
2137 if(!j->writers) {
2138 j->writers++;
2139 } else {
2140 if (file_p->f_mode & FMODE_READ){
2141 j->readers--;
2142 }
2143 return -EBUSY;
2144 }
2145 }
2146
2147 if (j->cardtype == QTI_PHONECARD) {
2148 j->pslic.bits.powerdown = 0;
2149 j->psccr.bits.dev = 3;
2150 j->psccr.bits.rw = 0;
2151 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2152 ixj_PCcontrol_wait(j);
2153 }
2154
2155 j->flags.cidplay = 0;
2156 j->flags.cidcw_ack = 0;
2157
2158 if (ixjdebug & 0x0002)
2159 printk(KERN_INFO "Opening board %d\n", p->board);
2160
2161 j->framesread = j->frameswritten = 0;
2162 return 0;
2163 }
2164
2165 static int ixj_release(struct inode *inode, struct file *file_p)
2166 {
2167 IXJ_TONE ti;
2168 int cnt;
2169 IXJ *j = file_p->private_data;
2170 int board = j->p.board;
2171
2172 /*
2173 * Set up locks to ensure that only one process is talking to the DSP at a time.
2174 * This is necessary to keep the DSP from locking up.
2175 */
2176 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2177 set_current_state(TASK_INTERRUPTIBLE);
2178 schedule_timeout(1);
2179 }
2180 if (ixjdebug & 0x0002)
2181 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2182
2183 if (j->cardtype == QTI_PHONECARD)
2184 ixj_set_port(j, PORT_SPEAKER);
2185 else
2186 ixj_set_port(j, PORT_POTS);
2187
2188 aec_stop(j);
2189 ixj_play_stop(j);
2190 ixj_record_stop(j);
2191 set_play_volume(j, 0x100);
2192 set_rec_volume(j, 0x100);
2193 ixj_ring_off(j);
2194
2195 /* Restore the tone table to default settings. */
2196 ti.tone_index = 10;
2197 ti.gain0 = 1;
2198 ti.freq0 = hz941;
2199 ti.gain1 = 0;
2200 ti.freq1 = hz1209;
2201 ixj_init_tone(j, &ti);
2202 ti.tone_index = 11;
2203 ti.gain0 = 1;
2204 ti.freq0 = hz941;
2205 ti.gain1 = 0;
2206 ti.freq1 = hz1336;
2207 ixj_init_tone(j, &ti);
2208 ti.tone_index = 12;
2209 ti.gain0 = 1;
2210 ti.freq0 = hz941;
2211 ti.gain1 = 0;
2212 ti.freq1 = hz1477;
2213 ixj_init_tone(j, &ti);
2214 ti.tone_index = 13;
2215 ti.gain0 = 1;
2216 ti.freq0 = hz800;
2217 ti.gain1 = 0;
2218 ti.freq1 = 0;
2219 ixj_init_tone(j, &ti);
2220 ti.tone_index = 14;
2221 ti.gain0 = 1;
2222 ti.freq0 = hz1000;
2223 ti.gain1 = 0;
2224 ti.freq1 = 0;
2225 ixj_init_tone(j, &ti);
2226 ti.tone_index = 15;
2227 ti.gain0 = 1;
2228 ti.freq0 = hz1250;
2229 ti.gain1 = 0;
2230 ti.freq1 = 0;
2231 ixj_init_tone(j, &ti);
2232 ti.tone_index = 16;
2233 ti.gain0 = 1;
2234 ti.freq0 = hz950;
2235 ti.gain1 = 0;
2236 ti.freq1 = 0;
2237 ixj_init_tone(j, &ti);
2238 ti.tone_index = 17;
2239 ti.gain0 = 1;
2240 ti.freq0 = hz1100;
2241 ti.gain1 = 0;
2242 ti.freq1 = 0;
2243 ixj_init_tone(j, &ti);
2244 ti.tone_index = 18;
2245 ti.gain0 = 1;
2246 ti.freq0 = hz1400;
2247 ti.gain1 = 0;
2248 ti.freq1 = 0;
2249 ixj_init_tone(j, &ti);
2250 ti.tone_index = 19;
2251 ti.gain0 = 1;
2252 ti.freq0 = hz1500;
2253 ti.gain1 = 0;
2254 ti.freq1 = 0;
2255 ixj_init_tone(j, &ti);
2256 ti.tone_index = 20;
2257 ti.gain0 = 1;
2258 ti.freq0 = hz1600;
2259 ti.gain1 = 0;
2260 ti.freq1 = 0;
2261 ixj_init_tone(j, &ti);
2262 ti.tone_index = 21;
2263 ti.gain0 = 1;
2264 ti.freq0 = hz1800;
2265 ti.gain1 = 0;
2266 ti.freq1 = 0;
2267 ixj_init_tone(j, &ti);
2268 ti.tone_index = 22;
2269 ti.gain0 = 1;
2270 ti.freq0 = hz2100;
2271 ti.gain1 = 0;
2272 ti.freq1 = 0;
2273 ixj_init_tone(j, &ti);
2274 ti.tone_index = 23;
2275 ti.gain0 = 1;
2276 ti.freq0 = hz1300;
2277 ti.gain1 = 0;
2278 ti.freq1 = 0;
2279 ixj_init_tone(j, &ti);
2280 ti.tone_index = 24;
2281 ti.gain0 = 1;
2282 ti.freq0 = hz2450;
2283 ti.gain1 = 0;
2284 ti.freq1 = 0;
2285 ixj_init_tone(j, &ti);
2286 ti.tone_index = 25;
2287 ti.gain0 = 1;
2288 ti.freq0 = hz350;
2289 ti.gain1 = 0;
2290 ti.freq1 = hz440;
2291 ixj_init_tone(j, &ti);
2292 ti.tone_index = 26;
2293 ti.gain0 = 1;
2294 ti.freq0 = hz440;
2295 ti.gain1 = 0;
2296 ti.freq1 = hz480;
2297 ixj_init_tone(j, &ti);
2298 ti.tone_index = 27;
2299 ti.gain0 = 1;
2300 ti.freq0 = hz480;
2301 ti.gain1 = 0;
2302 ti.freq1 = hz620;
2303 ixj_init_tone(j, &ti);
2304
2305 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2306
2307 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2308
2309 j->ex.bits.dtmf_ready = 0;
2310 j->dtmf_state = 0;
2311 j->dtmf_wp = j->dtmf_rp = 0;
2312 j->rec_mode = j->play_mode = -1;
2313 j->flags.ringing = 0;
2314 j->maxrings = MAXRINGS;
2315 j->ring_cadence = USA_RING_CADENCE;
2316 if(j->cadence_f[5].enable) {
2317 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2318 }
2319 j->drybuffer = 0;
2320 j->winktime = 320;
2321 j->flags.dtmf_oob = 0;
2322 for (cnt = 0; cnt < 4; cnt++)
2323 j->cadence_f[cnt].enable = 0;
2324
2325 idle(j);
2326
2327 if(j->cardtype == QTI_PHONECARD) {
2328 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2329 }
2330
2331 if (file_p->f_mode & FMODE_READ)
2332 j->readers--;
2333 if (file_p->f_mode & FMODE_WRITE)
2334 j->writers--;
2335
2336 if (j->read_buffer && !j->readers) {
2337 kfree(j->read_buffer);
2338 j->read_buffer = NULL;
2339 j->read_buffer_size = 0;
2340 }
2341 if (j->write_buffer && !j->writers) {
2342 kfree(j->write_buffer);
2343 j->write_buffer = NULL;
2344 j->write_buffer_size = 0;
2345 }
2346 j->rec_codec = j->play_codec = 0;
2347 j->rec_frame_size = j->play_frame_size = 0;
2348 j->flags.cidsent = j->flags.cidring = 0;
2349 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2350
2351 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2352 ixj_set_port(j, PORT_PSTN);
2353 daa_set_mode(j, SOP_PU_SLEEP);
2354 ixj_set_pots(j, 1);
2355 }
2356 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2357
2358 /* Set up the default signals for events */
2359 for (cnt = 0; cnt < 35; cnt++)
2360 j->ixj_signals[cnt] = SIGIO;
2361
2362 /* Set the excetion signal enable flags */
2363 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2364 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 =
2365 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;
2366
2367 file_p->private_data = NULL;
2368 clear_bit(board, &j->busyflags);
2369 return 0;
2370 }
2371
2372 static int read_filters(IXJ *j)
2373 {
2374 unsigned short fc, cnt, trg;
2375 int var;
2376
2377 trg = 0;
2378 if (ixj_WriteDSPCommand(0x5144, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Read Frame Counter failed!\n");
2381 }
2382 return -1;
2383 }
2384 fc = j->ssr.high << 8 | j->ssr.low;
2385 if (fc == j->frame_count)
2386 return 1;
2387
2388 j->frame_count = fc;
2389
2390 if (j->dtmf_proc)
2391 return 1;
2392
2393 var = 10;
2394
2395 for (cnt = 0; cnt < 4; cnt++) {
2396 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2397 if(ixjdebug & 0x0001) {
2398 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2399 }
2400 return -1;
2401 }
2402 if (ixj_WriteDSPCommand(0x515C, j)) {
2403 if(ixjdebug & 0x0001) {
2404 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2405 }
2406 return -1;
2407 }
2408 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2409
2410 if (j->cadence_f[cnt].enable) {
2411 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2412 if (j->cadence_f[cnt].state == 0) {
2413 j->cadence_f[cnt].state = 1;
2414 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2415 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2416 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2417 } else if (j->cadence_f[cnt].state == 2 &&
2418 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2419 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2420 if (j->cadence_f[cnt].on2) {
2421 j->cadence_f[cnt].state = 3;
2422 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2423 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2424 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2425 } else {
2426 j->cadence_f[cnt].state = 7;
2427 }
2428 } else if (j->cadence_f[cnt].state == 4 &&
2429 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2430 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2431 if (j->cadence_f[cnt].on3) {
2432 j->cadence_f[cnt].state = 5;
2433 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2434 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2435 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2436 } else {
2437 j->cadence_f[cnt].state = 7;
2438 }
2439 } else {
2440 j->cadence_f[cnt].state = 0;
2441 }
2442 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2443 if (j->cadence_f[cnt].state == 1) {
2444 if(!j->cadence_f[cnt].on1) {
2445 j->cadence_f[cnt].state = 7;
2446 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2447 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2448 if(j->cadence_f[cnt].off1) {
2449 j->cadence_f[cnt].state = 2;
2450 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2451 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2452 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2453 } else {
2454 j->cadence_f[cnt].state = 7;
2455 }
2456 } else {
2457 j->cadence_f[cnt].state = 0;
2458 }
2459 } else if (j->cadence_f[cnt].state == 3) {
2460 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2461 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2462 if(j->cadence_f[cnt].off2) {
2463 j->cadence_f[cnt].state = 4;
2464 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2465 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2466 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2467 } else {
2468 j->cadence_f[cnt].state = 7;
2469 }
2470 } else {
2471 j->cadence_f[cnt].state = 0;
2472 }
2473 } else if (j->cadence_f[cnt].state == 5) {
2474 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2475 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2476 if(j->cadence_f[cnt].off3) {
2477 j->cadence_f[cnt].state = 6;
2478 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2479 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2480 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2481 } else {
2482 j->cadence_f[cnt].state = 7;
2483 }
2484 } else {
2485 j->cadence_f[cnt].state = 0;
2486 }
2487 } else {
2488 j->cadence_f[cnt].state = 0;
2489 }
2490 } else {
2491 switch(j->cadence_f[cnt].state) {
2492 case 1:
2493 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2494 !j->cadence_f[cnt].off1 &&
2495 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2496 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2497 j->cadence_f[cnt].state = 7;
2498 }
2499 break;
2500 case 3:
2501 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2502 !j->cadence_f[cnt].off2 &&
2503 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2504 j->cadence_f[cnt].state = 7;
2505 }
2506 break;
2507 case 5:
2508 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2509 !j->cadence_f[cnt].off3) {
2510 j->cadence_f[cnt].state = 7;
2511 }
2512 break;
2513 }
2514 }
2515
2516 if (ixjdebug & 0x0040) {
2517 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2518 switch(j->cadence_f[cnt].state) {
2519 case 0:
2520 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2521 break;
2522 case 1:
2523 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2524 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2525 break;
2526 case 2:
2527 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2528 j->cadence_f[cnt].off1max);
2529 break;
2530 case 3:
2531 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2532 j->cadence_f[cnt].on2max);
2533 break;
2534 case 4:
2535 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2536 j->cadence_f[cnt].off2max);
2537 break;
2538 case 5:
2539 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2540 j->cadence_f[cnt].on3max);
2541 break;
2542 case 6:
2543 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2544 j->cadence_f[cnt].off3max);
2545 break;
2546 }
2547 }
2548 }
2549 if (j->cadence_f[cnt].state == 7) {
2550 j->cadence_f[cnt].state = 0;
2551 if (j->cadence_f[cnt].enable == 1)
2552 j->cadence_f[cnt].enable = 0;
2553 switch (cnt) {
2554 case 0:
2555 if(ixjdebug & 0x0020) {
2556 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2557 }
2558 j->ex.bits.fc0 = 1;
2559 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2560 break;
2561 case 1:
2562 if(ixjdebug & 0x0020) {
2563 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2564 }
2565 j->ex.bits.fc1 = 1;
2566 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2567 break;
2568 case 2:
2569 if(ixjdebug & 0x0020) {
2570 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2571 }
2572 j->ex.bits.fc2 = 1;
2573 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2574 break;
2575 case 3:
2576 if(ixjdebug & 0x0020) {
2577 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2578 }
2579 j->ex.bits.fc3 = 1;
2580 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2581 break;
2582 }
2583 }
2584 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2585 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2586 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2587 trg = 1;
2588 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2589 trg = 0;
2590 }
2591 switch (cnt) {
2592 case 0:
2593 if(ixjdebug & 0x0020) {
2594 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2595 }
2596 j->ex.bits.f0 = 1;
2597 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2598 break;
2599 case 1:
2600 if(ixjdebug & 0x0020) {
2601 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2602 }
2603 j->ex.bits.f1 = 1;
2604 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2605 break;
2606 case 2:
2607 if(ixjdebug & 0x0020) {
2608 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2609 }
2610 j->ex.bits.f2 = 1;
2611 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2612 break;
2613 case 3:
2614 if(ixjdebug & 0x0020) {
2615 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2616 }
2617 j->ex.bits.f3 = 1;
2618 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2619 break;
2620 }
2621 }
2622 }
2623 return 0;
2624 }
2625
2626 static int LineMonitor(IXJ *j)
2627 {
2628 if (j->dtmf_proc) {
2629 return -1;
2630 }
2631 j->dtmf_proc = 1;
2632
2633 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2634 return -1;
2635
2636 j->dtmf.bytes.high = j->ssr.high;
2637 j->dtmf.bytes.low = j->ssr.low;
2638 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2639 j->dtmf_state = 1;
2640 j->dtmf_current = j->dtmf.bits.digit;
2641 }
2642 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2643 {
2644 if(!j->cidcw_wait) {
2645 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2646 j->dtmf_wp++;
2647 if (j->dtmf_wp == 79)
2648 j->dtmf_wp = 0;
2649 j->ex.bits.dtmf_ready = 1;
2650 if(j->ex_sig.bits.dtmf_ready) {
2651 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2652 }
2653 }
2654 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2655 if(ixjdebug & 0x0020) {
2656 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2657 }
2658 j->flags.cidcw_ack = 1;
2659 }
2660 j->dtmf_state = 0;
2661 }
2662 j->dtmf_proc = 0;
2663
2664 return 0;
2665 }
2666
2667 /************************************************************************
2668 *
2669 * Functions to allow alaw <-> ulaw conversions.
2670 *
2671 ************************************************************************/
2672
2673 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2674 {
2675 static unsigned char table_ulaw2alaw[] =
2676 {
2677 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2678 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2679 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2680 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2681 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2682 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2683 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2684 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2685 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2686 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2687 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2688 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2689 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2690 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2691 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2692 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2693 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2694 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2695 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2696 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2697 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2698 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2699 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2700 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2701 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2702 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2703 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2704 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2705 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2706 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2707 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2708 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2709 };
2710
2711 while (len--)
2712 {
2713 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2714 buff++;
2715 }
2716 }
2717
2718 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2719 {
2720 static unsigned char table_alaw2ulaw[] =
2721 {
2722 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2723 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2724 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2725 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2726 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2727 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2728 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2729 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2730 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2731 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2732 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2733 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2734 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2735 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2736 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2737 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2738 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2739 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2740 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2741 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2742 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2743 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2744 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2745 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2746 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2747 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2748 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2749 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2750 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2751 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2752 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2753 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2754 };
2755
2756 while (len--)
2757 {
2758 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2759 buff++;
2760 }
2761 }
2762
2763 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2764 {
2765 unsigned long i = *ppos;
2766 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2767
2768 DECLARE_WAITQUEUE(wait, current);
2769
2770 if (j->flags.inread)
2771 return -EALREADY;
2772
2773 j->flags.inread = 1;
2774
2775 add_wait_queue(&j->read_q, &wait);
2776 set_current_state(TASK_INTERRUPTIBLE);
2777 mb();
2778
2779 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2780 ++j->read_wait;
2781 if (file_p->f_flags & O_NONBLOCK) {
2782 set_current_state(TASK_RUNNING);
2783 remove_wait_queue(&j->read_q, &wait);
2784 j->flags.inread = 0;
2785 return -EAGAIN;
2786 }
2787 if (!ixj_hookstate(j)) {
2788 set_current_state(TASK_RUNNING);
2789 remove_wait_queue(&j->read_q, &wait);
2790 j->flags.inread = 0;
2791 return 0;
2792 }
2793 interruptible_sleep_on(&j->read_q);
2794 if (signal_pending(current)) {
2795 set_current_state(TASK_RUNNING);
2796 remove_wait_queue(&j->read_q, &wait);
2797 j->flags.inread = 0;
2798 return -EINTR;
2799 }
2800 }
2801
2802 remove_wait_queue(&j->read_q, &wait);
2803 set_current_state(TASK_RUNNING);
2804 /* Don't ever copy more than the user asks */
2805 if(j->rec_codec == ALAW)
2806 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2807 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2808 j->read_buffer_ready = 0;
2809 if (i) {
2810 j->flags.inread = 0;
2811 return -EFAULT;
2812 } else {
2813 j->flags.inread = 0;
2814 return min(length, j->read_buffer_size);
2815 }
2816 }
2817
2818 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2819 loff_t * ppos)
2820 {
2821 int pre_retval;
2822 ssize_t read_retval = 0;
2823 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2824
2825 pre_retval = ixj_PreRead(j, 0L);
2826 switch (pre_retval) {
2827 case NORMAL:
2828 read_retval = ixj_read(file_p, buf, length, ppos);
2829 ixj_PostRead(j, 0L);
2830 break;
2831 case NOPOST:
2832 read_retval = ixj_read(file_p, buf, length, ppos);
2833 break;
2834 case POSTONLY:
2835 ixj_PostRead(j, 0L);
2836 break;
2837 default:
2838 read_retval = pre_retval;
2839 }
2840 return read_retval;
2841 }
2842
2843 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2844 {
2845 unsigned long i = *ppos;
2846 IXJ *j = file_p->private_data;
2847
2848 DECLARE_WAITQUEUE(wait, current);
2849
2850 if (j->flags.inwrite)
2851 return -EALREADY;
2852
2853 j->flags.inwrite = 1;
2854
2855 add_wait_queue(&j->write_q, &wait);
2856 set_current_state(TASK_INTERRUPTIBLE);
2857 mb();
2858
2859
2860 while (!j->write_buffers_empty) {
2861 ++j->write_wait;
2862 if (file_p->f_flags & O_NONBLOCK) {
2863 set_current_state(TASK_RUNNING);
2864 remove_wait_queue(&j->write_q, &wait);
2865 j->flags.inwrite = 0;
2866 return -EAGAIN;
2867 }
2868 if (!ixj_hookstate(j)) {
2869 set_current_state(TASK_RUNNING);
2870 remove_wait_queue(&j->write_q, &wait);
2871 j->flags.inwrite = 0;
2872 return 0;
2873 }
2874 interruptible_sleep_on(&j->write_q);
2875 if (signal_pending(current)) {
2876 set_current_state(TASK_RUNNING);
2877 remove_wait_queue(&j->write_q, &wait);
2878 j->flags.inwrite = 0;
2879 return -EINTR;
2880 }
2881 }
2882 set_current_state(TASK_RUNNING);
2883 remove_wait_queue(&j->write_q, &wait);
2884 if (j->write_buffer_wp + count >= j->write_buffer_end)
2885 j->write_buffer_wp = j->write_buffer;
2886 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2887 if (i) {
2888 j->flags.inwrite = 0;
2889 return -EFAULT;
2890 }
2891 if(j->play_codec == ALAW)
2892 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2893 j->flags.inwrite = 0;
2894 return min(count, j->write_buffer_size);
2895 }
2896
2897 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2898 {
2899 int pre_retval;
2900 ssize_t write_retval = 0;
2901
2902 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2903
2904 pre_retval = ixj_PreWrite(j, 0L);
2905 switch (pre_retval) {
2906 case NORMAL:
2907 write_retval = ixj_write(file_p, buf, count, ppos);
2908 if (write_retval > 0) {
2909 ixj_PostWrite(j, 0L);
2910 j->write_buffer_wp += write_retval;
2911 j->write_buffers_empty--;
2912 }
2913 break;
2914 case NOPOST:
2915 write_retval = ixj_write(file_p, buf, count, ppos);
2916 if (write_retval > 0) {
2917 j->write_buffer_wp += write_retval;
2918 j->write_buffers_empty--;
2919 }
2920 break;
2921 case POSTONLY:
2922 ixj_PostWrite(j, 0L);
2923 break;
2924 default:
2925 write_retval = pre_retval;
2926 }
2927 return write_retval;
2928 }
2929
2930 static void ixj_read_frame(IXJ *j)
2931 {
2932 int cnt, dly;
2933
2934 if (j->read_buffer) {
2935 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2936 if (!(cnt % 16) && !IsRxReady(j)) {
2937 dly = 0;
2938 while (!IsRxReady(j)) {
2939 if (dly++ > 5) {
2940 dly = 0;
2941 break;
2942 }
2943 udelay(10);
2944 }
2945 }
2946 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2947 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2948 inb_p(j->DSPbase + 0x0E);
2949 inb_p(j->DSPbase + 0x0F);
2950 }
2951 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2952 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2953 }
2954 ++j->framesread;
2955 if (j->intercom != -1) {
2956 if (IsTxReady(get_ixj(j->intercom))) {
2957 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2958 if (!(cnt % 16) && !IsTxReady(j)) {
2959 dly = 0;
2960 while (!IsTxReady(j)) {
2961 if (dly++ > 5) {
2962 dly = 0;
2963 break;
2964 }
2965 udelay(10);
2966 }
2967 }
2968 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2969 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2970 }
2971 get_ixj(j->intercom)->frameswritten++;
2972 }
2973 } else {
2974 j->read_buffer_ready = 1;
2975 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2976
2977 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2978
2979 if(j->ixj_signals[SIG_READ_READY])
2980 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2981 }
2982 }
2983 }
2984
2985 static short fsk[][6][20] =
2986 {
2987 {
2988 {
2989 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2990 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2991 },
2992 {
2993 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2994 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2995 },
2996 {
2997 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2998 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2999 },
3000 {
3001 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
3002 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
3003 },
3004 {
3005 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3006 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3007 },
3008 {
3009 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3010 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3011 }
3012 },
3013 {
3014 {
3015 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3016 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3017 },
3018 {
3019 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3020 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3021 },
3022 {
3023 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3024 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3025 },
3026 {
3027 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3028 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3029 },
3030 {
3031 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3032 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3033 },
3034 {
3035 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3036 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3037 }
3038 }
3039 };
3040
3041
3042 static void ixj_write_cid_bit(IXJ *j, int bit)
3043 {
3044 while (j->fskcnt < 20) {
3045 if(j->fskdcnt < (j->fsksize - 1))
3046 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3047
3048 j->fskcnt += 3;
3049 }
3050 j->fskcnt %= 20;
3051
3052 if (!bit)
3053 j->fskz++;
3054 if (j->fskz >= 6)
3055 j->fskz = 0;
3056
3057 }
3058
3059 static void ixj_write_cid_byte(IXJ *j, char byte)
3060 {
3061 IXJ_CBYTE cb;
3062
3063 cb.cbyte = byte;
3064 ixj_write_cid_bit(j, 0);
3065 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3066 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3067 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3068 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3069 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3070 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3071 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3072 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3073 ixj_write_cid_bit(j, 1);
3074 }
3075
3076 static void ixj_write_cid_seize(IXJ *j)
3077 {
3078 int cnt;
3079
3080 for (cnt = 0; cnt < 150; cnt++) {
3081 ixj_write_cid_bit(j, 0);
3082 ixj_write_cid_bit(j, 1);
3083 }
3084 for (cnt = 0; cnt < 180; cnt++) {
3085 ixj_write_cid_bit(j, 1);
3086 }
3087 }
3088
3089 static void ixj_write_cidcw_seize(IXJ *j)
3090 {
3091 int cnt;
3092
3093 for (cnt = 0; cnt < 80; cnt++) {
3094 ixj_write_cid_bit(j, 1);
3095 }
3096 }
3097
3098 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3099 {
3100 int cnt;
3101
3102 for (cnt = 0; cnt < strlen(s); cnt++) {
3103 ixj_write_cid_byte(j, s[cnt]);
3104 checksum = (checksum + s[cnt]);
3105 }
3106 return checksum;
3107 }
3108
3109 static void ixj_pad_fsk(IXJ *j, int pad)
3110 {
3111 int cnt;
3112
3113 for (cnt = 0; cnt < pad; cnt++) {
3114 if(j->fskdcnt < (j->fsksize - 1))
3115 j->fskdata[j->fskdcnt++] = 0x0000;
3116 }
3117 for (cnt = 0; cnt < 720; cnt++) {
3118 if(j->fskdcnt < (j->fsksize - 1))
3119 j->fskdata[j->fskdcnt++] = 0x0000;
3120 }
3121 }
3122
3123 static void ixj_pre_cid(IXJ *j)
3124 {
3125 j->cid_play_codec = j->play_codec;
3126 j->cid_play_frame_size = j->play_frame_size;
3127 j->cid_play_volume = get_play_volume(j);
3128 j->cid_play_flag = j->flags.playing;
3129
3130 j->cid_rec_codec = j->rec_codec;
3131 j->cid_rec_volume = get_rec_volume(j);
3132 j->cid_rec_flag = j->flags.recording;
3133
3134 j->cid_play_aec_level = j->aec_level;
3135
3136 switch(j->baseframe.low) {
3137 case 0xA0:
3138 j->cid_base_frame_size = 20;
3139 break;
3140 case 0x50:
3141 j->cid_base_frame_size = 10;
3142 break;
3143 case 0xF0:
3144 j->cid_base_frame_size = 30;
3145 break;
3146 }
3147
3148 ixj_play_stop(j);
3149 ixj_cpt_stop(j);
3150
3151 j->flags.cidplay = 1;
3152
3153 set_base_frame(j, 30);
3154 set_play_codec(j, LINEAR16);
3155 set_play_volume(j, 0x1B);
3156 ixj_play_start(j);
3157 }
3158
3159 static void ixj_post_cid(IXJ *j)
3160 {
3161 ixj_play_stop(j);
3162
3163 if(j->cidsize > 5000) {
3164 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3165 }
3166 j->flags.cidplay = 0;
3167 if(ixjdebug & 0x0200) {
3168 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3169 }
3170
3171 ixj_fsk_free(j);
3172
3173 j->fskdcnt = 0;
3174 set_base_frame(j, j->cid_base_frame_size);
3175 set_play_codec(j, j->cid_play_codec);
3176 ixj_aec_start(j, j->cid_play_aec_level);
3177 set_play_volume(j, j->cid_play_volume);
3178
3179 set_rec_codec(j, j->cid_rec_codec);
3180 set_rec_volume(j, j->cid_rec_volume);
3181
3182 if(j->cid_rec_flag)
3183 ixj_record_start(j);
3184
3185 if(j->cid_play_flag)
3186 ixj_play_start(j);
3187
3188 if(j->cid_play_flag) {
3189 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3190 }
3191 }
3192
3193 static void ixj_write_cid(IXJ *j)
3194 {
3195 char sdmf1[50];
3196 char sdmf2[50];
3197 char sdmf3[80];
3198 char mdmflen, len1, len2, len3;
3199 int pad;
3200
3201 int checksum = 0;
3202
3203 if (j->dsp.low == 0x20 || j->flags.cidplay)
3204 return;
3205
3206 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3207 j->cidsize = j->cidcnt = 0;
3208
3209 ixj_fsk_alloc(j);
3210
3211 strcpy(sdmf1, j->cid_send.month);
3212 strcat(sdmf1, j->cid_send.day);
3213 strcat(sdmf1, j->cid_send.hour);
3214 strcat(sdmf1, j->cid_send.min);
3215 strcpy(sdmf2, j->cid_send.number);
3216 strcpy(sdmf3, j->cid_send.name);
3217
3218 len1 = strlen(sdmf1);
3219 len2 = strlen(sdmf2);
3220 len3 = strlen(sdmf3);
3221 mdmflen = len1 + len2 + len3 + 6;
3222
3223 while(1){
3224 ixj_write_cid_seize(j);
3225
3226 ixj_write_cid_byte(j, 0x80);
3227 checksum = 0x80;
3228 ixj_write_cid_byte(j, mdmflen);
3229 checksum = checksum + mdmflen;
3230
3231 ixj_write_cid_byte(j, 0x01);
3232 checksum = checksum + 0x01;
3233 ixj_write_cid_byte(j, len1);
3234 checksum = checksum + len1;
3235 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3236 if(ixj_hookstate(j) & 1)
3237 break;
3238
3239 ixj_write_cid_byte(j, 0x02);
3240 checksum = checksum + 0x02;
3241 ixj_write_cid_byte(j, len2);
3242 checksum = checksum + len2;
3243 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3244 if(ixj_hookstate(j) & 1)
3245 break;
3246
3247 ixj_write_cid_byte(j, 0x07);
3248 checksum = checksum + 0x07;
3249 ixj_write_cid_byte(j, len3);
3250 checksum = checksum + len3;
3251 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3252 if(ixj_hookstate(j) & 1)
3253 break;
3254
3255 checksum %= 256;
3256 checksum ^= 0xFF;
3257 checksum += 1;
3258
3259 ixj_write_cid_byte(j, (char) checksum);
3260
3261 pad = j->fskdcnt % 240;
3262 if (pad) {
3263 pad = 240 - pad;
3264 }
3265 ixj_pad_fsk(j, pad);
3266 break;
3267 }
3268
3269 ixj_write_frame(j);
3270 }
3271
3272 static void ixj_write_cidcw(IXJ *j)
3273 {
3274 IXJ_TONE ti;
3275
3276 char sdmf1[50];
3277 char sdmf2[50];
3278 char sdmf3[80];
3279 char mdmflen, len1, len2, len3;
3280 int pad;
3281
3282 int checksum = 0;
3283
3284 if (j->dsp.low == 0x20 || j->flags.cidplay)
3285 return;
3286
3287 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3288 j->cidsize = j->cidcnt = 0;
3289
3290 ixj_fsk_alloc(j);
3291
3292 j->flags.cidcw_ack = 0;
3293
3294 ti.tone_index = 23;
3295 ti.gain0 = 1;
3296 ti.freq0 = hz440;
3297 ti.gain1 = 0;
3298 ti.freq1 = 0;
3299 ixj_init_tone(j, &ti);
3300
3301 ixj_set_tone_on(1500, j);
3302 ixj_set_tone_off(32, j);
3303 if(ixjdebug & 0x0200) {
3304 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3305 }
3306 ixj_play_tone(j, 23);
3307
3308 clear_bit(j->board, &j->busyflags);
3309 while(j->tone_state) {
3310 set_current_state(TASK_INTERRUPTIBLE);
3311 schedule_timeout(1);
3312 }
3313 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3314 set_current_state(TASK_INTERRUPTIBLE);
3315 schedule_timeout(1);
3316 }
3317 if(ixjdebug & 0x0200) {
3318 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3319 }
3320
3321 ti.tone_index = 24;
3322 ti.gain0 = 1;
3323 ti.freq0 = hz2130;
3324 ti.gain1 = 0;
3325 ti.freq1 = hz2750;
3326 ixj_init_tone(j, &ti);
3327
3328 ixj_set_tone_off(10, j);
3329 ixj_set_tone_on(600, j);
3330 if(ixjdebug & 0x0200) {
3331 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3332 }
3333 ixj_play_tone(j, 24);
3334
3335 clear_bit(j->board, &j->busyflags);
3336 while(j->tone_state) {
3337 set_current_state(TASK_INTERRUPTIBLE);
3338 schedule_timeout(1);
3339 }
3340 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3341 set_current_state(TASK_INTERRUPTIBLE);
3342 schedule_timeout(1);
3343 }
3344 if(ixjdebug & 0x0200) {
3345 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3346 }
3347
3348 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3349
3350 clear_bit(j->board, &j->busyflags);
3351 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3352 set_current_state(TASK_INTERRUPTIBLE);
3353 schedule_timeout(1);
3354 }
3355 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3356 set_current_state(TASK_INTERRUPTIBLE);
3357 schedule_timeout(1);
3358 }
3359 j->cidcw_wait = 0;
3360 if(!j->flags.cidcw_ack) {
3361 if(ixjdebug & 0x0200) {
3362 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3363 }
3364 ixj_post_cid(j);
3365 if(j->cid_play_flag) {
3366 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3367 }
3368 return;
3369 } else {
3370 ixj_pre_cid(j);
3371 }
3372 j->flags.cidcw_ack = 0;
3373 strcpy(sdmf1, j->cid_send.month);
3374 strcat(sdmf1, j->cid_send.day);
3375 strcat(sdmf1, j->cid_send.hour);
3376 strcat(sdmf1, j->cid_send.min);
3377 strcpy(sdmf2, j->cid_send.number);
3378 strcpy(sdmf3, j->cid_send.name);
3379
3380 len1 = strlen(sdmf1);
3381 len2 = strlen(sdmf2);
3382 len3 = strlen(sdmf3);
3383 mdmflen = len1 + len2 + len3 + 6;
3384
3385 ixj_write_cidcw_seize(j);
3386
3387 ixj_write_cid_byte(j, 0x80);
3388 checksum = 0x80;
3389 ixj_write_cid_byte(j, mdmflen);
3390 checksum = checksum + mdmflen;
3391
3392 ixj_write_cid_byte(j, 0x01);
3393 checksum = checksum + 0x01;
3394 ixj_write_cid_byte(j, len1);
3395 checksum = checksum + len1;
3396 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3397
3398 ixj_write_cid_byte(j, 0x02);
3399 checksum = checksum + 0x02;
3400 ixj_write_cid_byte(j, len2);
3401 checksum = checksum + len2;
3402 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3403
3404 ixj_write_cid_byte(j, 0x07);
3405 checksum = checksum + 0x07;
3406 ixj_write_cid_byte(j, len3);
3407 checksum = checksum + len3;
3408 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3409
3410 checksum %= 256;
3411 checksum ^= 0xFF;
3412 checksum += 1;
3413
3414 ixj_write_cid_byte(j, (char) checksum);
3415
3416 pad = j->fskdcnt % 240;
3417 if (pad) {
3418 pad = 240 - pad;
3419 }
3420 ixj_pad_fsk(j, pad);
3421 if(ixjdebug & 0x0200) {
3422 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3423 }
3424 }
3425
3426 static void ixj_write_vmwi(IXJ *j, int msg)
3427 {
3428 char mdmflen;
3429 int pad;
3430
3431 int checksum = 0;
3432
3433 if (j->dsp.low == 0x20 || j->flags.cidplay)
3434 return;
3435
3436 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3437 j->cidsize = j->cidcnt = 0;
3438
3439 ixj_fsk_alloc(j);
3440
3441 mdmflen = 3;
3442
3443 if (j->port == PORT_POTS)
3444 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3445
3446 ixj_write_cid_seize(j);
3447
3448 ixj_write_cid_byte(j, 0x82);
3449 checksum = 0x82;
3450 ixj_write_cid_byte(j, mdmflen);
3451 checksum = checksum + mdmflen;
3452
3453 ixj_write_cid_byte(j, 0x0B);
3454 checksum = checksum + 0x0B;
3455 ixj_write_cid_byte(j, 1);
3456 checksum = checksum + 1;
3457
3458 if(msg) {
3459 ixj_write_cid_byte(j, 0xFF);
3460 checksum = checksum + 0xFF;
3461 }
3462 else {
3463 ixj_write_cid_byte(j, 0x00);
3464 checksum = checksum + 0x00;
3465 }
3466
3467 checksum %= 256;
3468 checksum ^= 0xFF;
3469 checksum += 1;
3470
3471 ixj_write_cid_byte(j, (char) checksum);
3472
3473 pad = j->fskdcnt % 240;
3474 if (pad) {
3475 pad = 240 - pad;
3476 }
3477 ixj_pad_fsk(j, pad);
3478 }
3479
3480 static void ixj_write_frame(IXJ *j)
3481 {
3482 int cnt, frame_count, dly;
3483 IXJ_WORD dat;
3484 BYTES blankword;
3485
3486 frame_count = 0;
3487 if(j->flags.cidplay) {
3488 for(cnt = 0; cnt < 480; cnt++) {
3489 if (!(cnt % 16) && !IsTxReady(j)) {
3490 dly = 0;
3491 while (!IsTxReady(j)) {
3492 if (dly++ > 5) {
3493 dly = 0;
3494 break;
3495 }
3496 udelay(10);
3497 }
3498 }
3499 dat.word = j->fskdata[j->cidcnt++];
3500 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3501 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3502 cnt++;
3503 }
3504 if(j->cidcnt >= j->fskdcnt) {
3505 ixj_post_cid(j);
3506 }
3507 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3508 and there is real audio data in the buffer, we need to throw it away because
3509 we just used it's time slot */
3510 if (j->write_buffer_rp > j->write_buffer_wp) {
3511 j->write_buffer_rp += j->cid_play_frame_size * 2;
3512 if (j->write_buffer_rp >= j->write_buffer_end) {
3513 j->write_buffer_rp = j->write_buffer;
3514 }
3515 j->write_buffers_empty++;
3516 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3517
3518 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3519 }
3520 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3521 if (j->write_buffer_wp > j->write_buffer_rp) {
3522 frame_count =
3523 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3524 }
3525 if (j->write_buffer_rp > j->write_buffer_wp) {
3526 frame_count =
3527 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3528 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3529 }
3530 if (frame_count >= 1) {
3531 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3532 switch (j->play_mode) {
3533 case PLAYBACK_MODE_ULAW:
3534 case PLAYBACK_MODE_ALAW:
3535 blankword.low = blankword.high = 0xFF;
3536 break;
3537 case PLAYBACK_MODE_8LINEAR:
3538 case PLAYBACK_MODE_16LINEAR:
3539 blankword.low = blankword.high = 0x00;
3540 break;
3541 case PLAYBACK_MODE_8LINEAR_WSS:
3542 blankword.low = blankword.high = 0x80;
3543 break;
3544 }
3545 for (cnt = 0; cnt < 16; cnt++) {
3546 if (!(cnt % 16) && !IsTxReady(j)) {
3547 dly = 0;
3548 while (!IsTxReady(j)) {
3549 if (dly++ > 5) {
3550 dly = 0;
3551 break;
3552 }
3553 udelay(10);
3554 }
3555 }
3556 outb_p((blankword.low), j->DSPbase + 0x0C);
3557 outb_p((blankword.high), j->DSPbase + 0x0D);
3558 }
3559 j->flags.play_first_frame = 0;
3560 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3561 for (cnt = 0; cnt < 24; cnt++) {
3562 if(cnt == 12) {
3563 blankword.low = 0x02;
3564 blankword.high = 0x00;
3565 }
3566 else {
3567 blankword.low = blankword.high = 0x00;
3568 }
3569 if (!(cnt % 16) && !IsTxReady(j)) {
3570 dly = 0;
3571 while (!IsTxReady(j)) {
3572 if (dly++ > 5) {
3573 dly = 0;
3574 break;
3575 }
3576 udelay(10);
3577 }
3578 }
3579 outb_p((blankword.low), j->DSPbase + 0x0C);
3580 outb_p((blankword.high), j->DSPbase + 0x0D);
3581 }
3582 j->flags.play_first_frame = 0;
3583 }
3584 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3585 if (!(cnt % 16) && !IsTxReady(j)) {
3586 dly = 0;
3587 while (!IsTxReady(j)) {
3588 if (dly++ > 5) {
3589 dly = 0;
3590 break;
3591 }
3592 udelay(10);
3593 }
3594 }
3595 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3596 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3597 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3598 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3599 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3600 j->write_buffer_rp + cnt + 9 == 0) {
3601 /* someone is trying to write silence lets make this a type 0 frame. */
3602 outb_p(0x00, j->DSPbase + 0x0C);
3603 outb_p(0x00, j->DSPbase + 0x0D);
3604 } else {
3605 /* so all other frames are type 1. */
3606 outb_p(0x01, j->DSPbase + 0x0C);
3607 outb_p(0x00, j->DSPbase + 0x0D);
3608 }
3609 }
3610 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3611 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3612 *(j->write_buffer_rp + cnt) = 0;
3613 *(j->write_buffer_rp + cnt + 1) = 0;
3614 }
3615 j->write_buffer_rp += j->play_frame_size * 2;
3616 if (j->write_buffer_rp >= j->write_buffer_end) {
3617 j->write_buffer_rp = j->write_buffer;
3618 }
3619 j->write_buffers_empty++;
3620 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3621
3622 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3623
3624 ++j->frameswritten;
3625 }
3626 } else {
3627 j->drybuffer++;
3628 }
3629 if(j->ixj_signals[SIG_WRITE_READY]) {
3630 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3631 }
3632 }
3633
3634 static int idle(IXJ *j)
3635 {
3636 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3637
3638 return 0;
3639
3640 if (j->ssr.high || j->ssr.low) {
3641 return 0;
3642 } else {
3643 j->play_mode = -1;
3644 j->flags.playing = 0;
3645 j->rec_mode = -1;
3646 j->flags.recording = 0;
3647 return 1;
3648 }
3649 }
3650
3651 static int set_base_frame(IXJ *j, int size)
3652 {
3653 unsigned short cmd;
3654 int cnt;
3655
3656 idle(j);
3657 j->cid_play_aec_level = j->aec_level;
3658 aec_stop(j);
3659 for (cnt = 0; cnt < 10; cnt++) {
3660 if (idle(j))
3661 break;
3662 }
3663 if (j->ssr.high || j->ssr.low)
3664 return -1;
3665 if (j->dsp.low != 0x20) {
3666 switch (size) {
3667 case 30:
3668 cmd = 0x07F0;
3669 /* Set Base Frame Size to 240 pg9-10 8021 */
3670 break;
3671 case 20:
3672 cmd = 0x07A0;
3673 /* Set Base Frame Size to 160 pg9-10 8021 */
3674 break;
3675 case 10:
3676 cmd = 0x0750;
3677 /* Set Base Frame Size to 80 pg9-10 8021 */
3678 break;
3679 default:
3680 return -1;
3681 }
3682 } else {
3683 if (size == 30)
3684 return size;
3685 else
3686 return -1;
3687 }
3688 if (ixj_WriteDSPCommand(cmd, j)) {
3689 j->baseframe.high = j->baseframe.low = 0xFF;
3690 return -1;
3691 } else {
3692 j->baseframe.high = j->ssr.high;
3693 j->baseframe.low = j->ssr.low;
3694 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3695 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3696 return -1;
3697 }
3698 }
3699 ixj_aec_start(j, j->cid_play_aec_level);
3700 return size;
3701 }
3702
3703 static int set_rec_codec(IXJ *j, int rate)
3704 {
3705 int retval = 0;
3706
3707 j->rec_codec = rate;
3708
3709 switch (rate) {
3710 case G723_63:
3711 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3712 j->rec_frame_size = 12;
3713 j->rec_mode = 0;
3714 } else {
3715 retval = 1;
3716 }
3717 break;
3718 case G723_53:
3719 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3720 j->rec_frame_size = 10;
3721 j->rec_mode = 0;
3722 } else {
3723 retval = 1;
3724 }
3725 break;
3726 case TS85:
3727 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3728 j->rec_frame_size = 16;
3729 j->rec_mode = 0;
3730 } else {
3731 retval = 1;
3732 }
3733 break;
3734 case TS48:
3735 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3736 j->rec_frame_size = 9;
3737 j->rec_mode = 0;
3738 } else {
3739 retval = 1;
3740 }
3741 break;
3742 case TS41:
3743 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3744 j->rec_frame_size = 8;
3745 j->rec_mode = 0;
3746 } else {
3747 retval = 1;
3748 }
3749 break;
3750 case G728:
3751 if (j->dsp.low != 0x20) {
3752 j->rec_frame_size = 48;
3753 j->rec_mode = 0;
3754 } else {
3755 retval = 1;
3756 }
3757 break;
3758 case G729:
3759 if (j->dsp.low != 0x20) {
3760 if (!j->flags.g729_loaded) {
3761 retval = 1;
3762 break;
3763 }
3764 switch (j->baseframe.low) {
3765 case 0xA0:
3766 j->rec_frame_size = 10;
3767 break;
3768 case 0x50:
3769 j->rec_frame_size = 5;
3770 break;
3771 default:
3772 j->rec_frame_size = 15;
3773 break;
3774 }
3775 j->rec_mode = 0;
3776 } else {
3777 retval = 1;
3778 }
3779 break;
3780 case G729B:
3781 if (j->dsp.low != 0x20) {
3782 if (!j->flags.g729_loaded) {
3783 retval = 1;
3784 break;
3785 }
3786 switch (j->baseframe.low) {
3787 case 0xA0:
3788 j->rec_frame_size = 12;
3789 break;
3790 case 0x50:
3791 j->rec_frame_size = 6;
3792 break;
3793 default:
3794 j->rec_frame_size = 18;
3795 break;
3796 }
3797 j->rec_mode = 0;
3798 } else {
3799 retval = 1;
3800 }
3801 break;
3802 case ULAW:
3803 switch (j->baseframe.low) {
3804 case 0xA0:
3805 j->rec_frame_size = 80;
3806 break;
3807 case 0x50:
3808 j->rec_frame_size = 40;
3809 break;
3810 default:
3811 j->rec_frame_size = 120;
3812 break;
3813 }
3814 j->rec_mode = 4;
3815 break;
3816 case ALAW:
3817 switch (j->baseframe.low) {
3818 case 0xA0:
3819 j->rec_frame_size = 80;
3820 break;
3821 case 0x50:
3822 j->rec_frame_size = 40;
3823 break;
3824 default:
3825 j->rec_frame_size = 120;
3826 break;
3827 }
3828 j->rec_mode = 4;
3829 break;
3830 case LINEAR16:
3831 switch (j->baseframe.low) {
3832 case 0xA0:
3833 j->rec_frame_size = 160;
3834 break;
3835 case 0x50:
3836 j->rec_frame_size = 80;
3837 break;
3838 default:
3839 j->rec_frame_size = 240;
3840 break;
3841 }
3842 j->rec_mode = 5;
3843 break;
3844 case LINEAR8:
3845 switch (j->baseframe.low) {
3846 case 0xA0:
3847 j->rec_frame_size = 80;
3848 break;
3849 case 0x50:
3850 j->rec_frame_size = 40;
3851 break;
3852 default:
3853 j->rec_frame_size = 120;
3854 break;
3855 }
3856 j->rec_mode = 6;
3857 break;
3858 case WSS:
3859 switch (j->baseframe.low) {
3860 case 0xA0:
3861 j->rec_frame_size = 80;
3862 break;
3863 case 0x50:
3864 j->rec_frame_size = 40;
3865 break;
3866 default:
3867 j->rec_frame_size = 120;
3868 break;
3869 }
3870 j->rec_mode = 7;
3871 break;
3872 default:
3873 j->rec_frame_size = 0;
3874 j->rec_mode = -1;
3875 if (j->read_buffer) {
3876 kfree(j->read_buffer);
3877 j->read_buffer = NULL;
3878 j->read_buffer_size = 0;
3879 }
3880 retval = 1;
3881 break;
3882 }
3883 return retval;
3884 }
3885
3886 static int ixj_record_start(IXJ *j)
3887 {
3888 unsigned short cmd = 0x0000;
3889
3890 if (j->read_buffer) {
3891 ixj_record_stop(j);
3892 }
3893 j->flags.recording = 1;
3894 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3895
3896 if(ixjdebug & 0x0002)
3897 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3898
3899 if (!j->rec_mode) {
3900 switch (j->rec_codec) {
3901 case G723_63:
3902 cmd = 0x5131;
3903 break;
3904 case G723_53:
3905 cmd = 0x5132;
3906 break;
3907 case TS85:
3908 cmd = 0x5130; /* TrueSpeech 8.5 */
3909
3910 break;
3911 case TS48:
3912 cmd = 0x5133; /* TrueSpeech 4.8 */
3913
3914 break;
3915 case TS41:
3916 cmd = 0x5134; /* TrueSpeech 4.1 */
3917
3918 break;
3919 case G728:
3920 cmd = 0x5135;
3921 break;
3922 case G729:
3923 case G729B:
3924 cmd = 0x5136;
3925 break;
3926 default:
3927 return 1;
3928 }
3929 if (ixj_WriteDSPCommand(cmd, j))
3930 return -1;
3931 }
3932 if (!j->read_buffer) {
3933 if (!j->read_buffer)
3934 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3935 if (!j->read_buffer) {
3936 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3937 return -ENOMEM;
3938 }
3939 }
3940 j->read_buffer_size = j->rec_frame_size * 2;
3941
3942 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3943
3944 return -1;
3945
3946 switch (j->rec_mode) {
3947 case 0:
3948 cmd = 0x1C03; /* Record C1 */
3949
3950 break;
3951 case 4:
3952 if (j->ver.low == 0x12) {
3953 cmd = 0x1E03; /* Record C1 */
3954
3955 } else {
3956 cmd = 0x1E01; /* Record C1 */
3957
3958 }
3959 break;
3960 case 5:
3961 if (j->ver.low == 0x12) {
3962 cmd = 0x1E83; /* Record C1 */
3963
3964 } else {
3965 cmd = 0x1E81; /* Record C1 */
3966
3967 }
3968 break;
3969 case 6:
3970 if (j->ver.low == 0x12) {
3971 cmd = 0x1F03; /* Record C1 */
3972
3973 } else {
3974 cmd = 0x1F01; /* Record C1 */
3975
3976 }
3977 break;
3978 case 7:
3979 if (j->ver.low == 0x12) {
3980 cmd = 0x1F83; /* Record C1 */
3981 } else {
3982 cmd = 0x1F81; /* Record C1 */
3983 }
3984 break;
3985 }
3986 if (ixj_WriteDSPCommand(cmd, j))
3987 return -1;
3988
3989 if (j->flags.playing) {
3990 ixj_aec_start(j, j->aec_level);
3991 }
3992 return 0;
3993 }
3994
3995 static void ixj_record_stop(IXJ *j)
3996 {
3997 if(ixjdebug & 0x0002)
3998 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3999
4000 if (j->read_buffer) {
4001 kfree(j->read_buffer);
4002 j->read_buffer = NULL;
4003 j->read_buffer_size = 0;
4004 }
4005 if (j->rec_mode > -1) {
4006 ixj_WriteDSPCommand(0x5120, j);
4007 j->rec_mode = -1;
4008 }
4009 j->flags.recording = 0;
4010 }
4011 static void ixj_vad(IXJ *j, int arg)
4012 {
4013 if (arg)
4014 ixj_WriteDSPCommand(0x513F, j);
4015 else
4016 ixj_WriteDSPCommand(0x513E, j);
4017 }
4018
4019 static void set_rec_depth(IXJ *j, int depth)
4020 {
4021 if (depth > 60)
4022 depth = 60;
4023 if (depth < 0)
4024 depth = 0;
4025 ixj_WriteDSPCommand(0x5180 + depth, j);
4026 }
4027
4028 static void set_dtmf_prescale(IXJ *j, int volume)
4029 {
4030 ixj_WriteDSPCommand(0xCF07, j);
4031 ixj_WriteDSPCommand(volume, j);
4032 }
4033
4034 static int get_dtmf_prescale(IXJ *j)
4035 {
4036 ixj_WriteDSPCommand(0xCF05, j);
4037 return j->ssr.high << 8 | j->ssr.low;
4038 }
4039
4040 static void set_rec_volume(IXJ *j, int volume)
4041 {
4042 if(j->aec_level == AEC_AGC) {
4043 if (ixjdebug & 0x0002)
4044 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4045 ixj_WriteDSPCommand(0xCF96, j);
4046 ixj_WriteDSPCommand(volume, j);
4047 } else {
4048 if (ixjdebug & 0x0002)
4049 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4050 ixj_WriteDSPCommand(0xCF03, j);
4051 ixj_WriteDSPCommand(volume, j);
4052 }
4053 }
4054
4055 static int set_rec_volume_linear(IXJ *j, int volume)
4056 {
4057 int newvolume, dsprecmax;
4058
4059 if (ixjdebug & 0x0002)
4060 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4061 if(volume > 100 || volume < 0) {
4062 return -1;
4063 }
4064
4065 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4066 switch (j->cardtype) {
4067 case QTI_PHONEJACK:
4068 dsprecmax = 0x440;
4069 break;
4070 case QTI_LINEJACK:
4071 dsprecmax = 0x180;
4072 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4073 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4074 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4075 break;
4076 case QTI_PHONEJACK_LITE:
4077 dsprecmax = 0x4C0;
4078 break;
4079 case QTI_PHONEJACK_PCI:
4080 dsprecmax = 0x100;
4081 break;
4082 case QTI_PHONECARD:
4083 dsprecmax = 0x400;
4084 break;
4085 default:
4086 return -1;
4087 }
4088 newvolume = (dsprecmax * volume) / 100;
4089 set_rec_volume(j, newvolume);
4090 return 0;
4091 }
4092
4093 static int get_rec_volume(IXJ *j)
4094 {
4095 if(j->aec_level == AEC_AGC) {
4096 if (ixjdebug & 0x0002)
4097 printk(KERN_INFO "Getting AGC Threshold\n");
4098 ixj_WriteDSPCommand(0xCF86, j);
4099 if (ixjdebug & 0x0002)
4100 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4101 return j->ssr.high << 8 | j->ssr.low;
4102 } else {
4103 if (ixjdebug & 0x0002)
4104 printk(KERN_INFO "Getting Record Volume\n");
4105 ixj_WriteDSPCommand(0xCF01, j);
4106 return j->ssr.high << 8 | j->ssr.low;
4107 }
4108 }
4109
4110 static int get_rec_volume_linear(IXJ *j)
4111 {
4112 int volume, newvolume, dsprecmax;
4113
4114 switch (j->cardtype) {
4115 case QTI_PHONEJACK:
4116 dsprecmax = 0x440;
4117 break;
4118 case QTI_LINEJACK:
4119 dsprecmax = 0x180;
4120 break;
4121 case QTI_PHONEJACK_LITE:
4122 dsprecmax = 0x4C0;
4123 break;
4124 case QTI_PHONEJACK_PCI:
4125 dsprecmax = 0x100;
4126 break;
4127 case QTI_PHONECARD:
4128 dsprecmax = 0x400;
4129 break;
4130 default:
4131 return -1;
4132 }
4133 volume = get_rec_volume(j);
4134 newvolume = (volume * 100) / dsprecmax;
4135 if(newvolume > 100)
4136 newvolume = 100;
4137 return newvolume;
4138 }
4139
4140 static int get_rec_level(IXJ *j)
4141 {
4142 int retval;
4143
4144 ixj_WriteDSPCommand(0xCF88, j);
4145
4146 retval = j->ssr.high << 8 | j->ssr.low;
4147 retval = (retval * 256) / 240;
4148 return retval;
4149 }
4150
4151 static void ixj_aec_start(IXJ *j, int level)
4152 {
4153 j->aec_level = level;
4154 if (ixjdebug & 0x0002)
4155 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4156 if (!level) {
4157 aec_stop(j);
4158 } else {
4159 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4160 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4161
4162 ixj_WriteDSPCommand(0x0300, j);
4163 }
4164 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4165
4166 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4167
4168 switch (level) {
4169 case AEC_LOW:
4170 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4171
4172 ixj_WriteDSPCommand(0xE011, j);
4173 ixj_WriteDSPCommand(0xFFFF, j);
4174
4175 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4176 ixj_WriteDSPCommand(0x0000, j); /* to off */
4177
4178 break;
4179
4180 case AEC_MED:
4181 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4182
4183 ixj_WriteDSPCommand(0xE011, j);
4184 ixj_WriteDSPCommand(0x0080, j);
4185
4186 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4187 ixj_WriteDSPCommand(0x0000, j); /* to off */
4188
4189 break;
4190
4191 case AEC_HIGH:
4192 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4193
4194 ixj_WriteDSPCommand(0xE011, j);
4195 ixj_WriteDSPCommand(0x0080, j);
4196
4197 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4198 ixj_WriteDSPCommand(0x0000, j); /* to off */
4199
4200 break;
4201
4202 case AEC_AGC:
4203 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4204 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4205
4206 ixj_WriteDSPCommand(0xE011, j);
4207 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4208
4209 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4210
4211 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4212 ixj_WriteDSPCommand(0x0224, j);
4213 else
4214 ixj_WriteDSPCommand(0x1224, j);
4215
4216 ixj_WriteDSPCommand(0xE014, j);
4217 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4218
4219 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4220
4221 /* Now we can set the AGC initial parameters and turn it on */
4222 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4223 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4224
4225 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4226 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4227
4228 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4229 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4230
4231 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4232 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4233
4234 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4235 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4236
4237 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4238 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4239
4240 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4241 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4242
4243 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4244 ixj_WriteDSPCommand(0x0001, j); /* to on */
4245
4246 break;
4247
4248 case AEC_AUTO:
4249 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4250
4251 ixj_WriteDSPCommand(0xE011, j);
4252 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4253
4254 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4255
4256 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4257 ixj_WriteDSPCommand(0x0224, j);
4258 else
4259 ixj_WriteDSPCommand(0x1224, j);
4260
4261 ixj_WriteDSPCommand(0xE014, j);
4262 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4263
4264 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4265
4266 break;
4267 }
4268 }
4269 }
4270
4271 static void aec_stop(IXJ *j)
4272 {
4273 j->aec_level = AEC_OFF;
4274 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4275 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4276
4277 ixj_WriteDSPCommand(0x0700, j);
4278 }
4279 if (j->play_mode != -1 && j->rec_mode != -1)
4280 {
4281 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4282 }
4283 }
4284
4285 static int set_play_codec(IXJ *j, int rate)
4286 {
4287 int retval = 0;
4288
4289 j->play_codec = rate;
4290
4291 switch (rate) {
4292 case G723_63:
4293 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294 j->play_frame_size = 12;
4295 j->play_mode = 0;
4296 } else {
4297 retval = 1;
4298 }
4299 break;
4300 case G723_53:
4301 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302 j->play_frame_size = 10;
4303 j->play_mode = 0;
4304 } else {
4305 retval = 1;
4306 }
4307 break;
4308 case TS85:
4309 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4310 j->play_frame_size = 16;
4311 j->play_mode = 0;
4312 } else {
4313 retval = 1;
4314 }
4315 break;
4316 case TS48:
4317 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4318 j->play_frame_size = 9;
4319 j->play_mode = 0;
4320 } else {
4321 retval = 1;
4322 }
4323 break;
4324 case TS41:
4325 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4326 j->play_frame_size = 8;
4327 j->play_mode = 0;
4328 } else {
4329 retval = 1;
4330 }
4331 break;
4332 case G728:
4333 if (j->dsp.low != 0x20) {
4334 j->play_frame_size = 48;
4335 j->play_mode = 0;
4336 } else {
4337 retval = 1;
4338 }
4339 break;
4340 case G729:
4341 if (j->dsp.low != 0x20) {
4342 if (!j->flags.g729_loaded) {
4343 retval = 1;
4344 break;
4345 }
4346 switch (j->baseframe.low) {
4347 case 0xA0:
4348 j->play_frame_size = 10;
4349 break;
4350 case 0x50:
4351 j->play_frame_size = 5;
4352 break;
4353 default:
4354 j->play_frame_size = 15;
4355 break;
4356 }
4357 j->play_mode = 0;
4358 } else {
4359 retval = 1;
4360 }
4361 break;
4362 case G729B:
4363 if (j->dsp.low != 0x20) {
4364 if (!j->flags.g729_loaded) {
4365 retval = 1;
4366 break;
4367 }
4368 switch (j->baseframe.low) {
4369 case 0xA0:
4370 j->play_frame_size = 12;
4371 break;
4372 case 0x50:
4373 j->play_frame_size = 6;
4374 break;
4375 default:
4376 j->play_frame_size = 18;
4377 break;
4378 }
4379 j->play_mode = 0;
4380 } else {
4381 retval = 1;
4382 }
4383 break;
4384 case ULAW:
4385 switch (j->baseframe.low) {
4386 case 0xA0:
4387 j->play_frame_size = 80;
4388 break;
4389 case 0x50:
4390 j->play_frame_size = 40;
4391 break;
4392 default:
4393 j->play_frame_size = 120;
4394 break;
4395 }
4396 j->play_mode = 2;
4397 break;
4398 case ALAW:
4399 switch (j->baseframe.low) {
4400 case 0xA0:
4401 j->play_frame_size = 80;
4402 break;
4403 case 0x50:
4404 j->play_frame_size = 40;
4405 break;
4406 default:
4407 j->play_frame_size = 120;
4408 break;
4409 }
4410 j->play_mode = 2;
4411 break;
4412 case LINEAR16:
4413 switch (j->baseframe.low) {
4414 case 0xA0:
4415 j->play_frame_size = 160;
4416 break;
4417 case 0x50:
4418 j->play_frame_size = 80;
4419 break;
4420 default:
4421 j->play_frame_size = 240;
4422 break;
4423 }
4424 j->play_mode = 6;
4425 break;
4426 case LINEAR8:
4427 switch (j->baseframe.low) {
4428 case 0xA0:
4429 j->play_frame_size = 80;
4430 break;
4431 case 0x50:
4432 j->play_frame_size = 40;
4433 break;
4434 default:
4435 j->play_frame_size = 120;
4436 break;
4437 }
4438 j->play_mode = 4;
4439 break;
4440 case WSS:
4441 switch (j->baseframe.low) {
4442 case 0xA0:
4443 j->play_frame_size = 80;
4444 break;
4445 case 0x50:
4446 j->play_frame_size = 40;
4447 break;
4448 default:
4449 j->play_frame_size = 120;
4450 break;
4451 }
4452 j->play_mode = 5;
4453 break;
4454 default:
4455 j->play_frame_size = 0;
4456 j->play_mode = -1;
4457 if (j->write_buffer) {
4458 kfree(j->write_buffer);
4459 j->write_buffer = NULL;
4460 j->write_buffer_size = 0;
4461 }
4462 retval = 1;
4463 break;
4464 }
4465 return retval;
4466 }
4467
4468 static int ixj_play_start(IXJ *j)
4469 {
4470 unsigned short cmd = 0x0000;
4471
4472 if (j->write_buffer) {
4473 ixj_play_stop(j);
4474 }
4475
4476 if(ixjdebug & 0x0002)
4477 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4478
4479 j->flags.playing = 1;
4480 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4481
4482 j->flags.play_first_frame = 1;
4483 j->drybuffer = 0;
4484
4485 if (!j->play_mode) {
4486 switch (j->play_codec) {
4487 case G723_63:
4488 cmd = 0x5231;
4489 break;
4490 case G723_53:
4491 cmd = 0x5232;
4492 break;
4493 case TS85:
4494 cmd = 0x5230; /* TrueSpeech 8.5 */
4495
4496 break;
4497 case TS48:
4498 cmd = 0x5233; /* TrueSpeech 4.8 */
4499
4500 break;
4501 case TS41:
4502 cmd = 0x5234; /* TrueSpeech 4.1 */
4503
4504 break;
4505 case G728:
4506 cmd = 0x5235;
4507 break;
4508 case G729:
4509 case G729B:
4510 cmd = 0x5236;
4511 break;
4512 default:
4513 return 1;
4514 }
4515 if (ixj_WriteDSPCommand(cmd, j))
4516 return -1;
4517 }
4518 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4519 if (!j->write_buffer) {
4520 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4521 return -ENOMEM;
4522 }
4523 /* j->write_buffers_empty = 2; */
4524 j->write_buffers_empty = 1;
4525 j->write_buffer_size = j->play_frame_size * 2;
4526 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4527 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4528
4529 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4530
4531 return -1;
4532
4533 switch (j->play_mode) {
4534 case 0:
4535 cmd = 0x2C03;
4536 break;
4537 case 2:
4538 if (j->ver.low == 0x12) {
4539 cmd = 0x2C23;
4540 } else {
4541 cmd = 0x2C21;
4542 }
4543 break;
4544 case 4:
4545 if (j->ver.low == 0x12) {
4546 cmd = 0x2C43;
4547 } else {
4548 cmd = 0x2C41;
4549 }
4550 break;
4551 case 5:
4552 if (j->ver.low == 0x12) {
4553 cmd = 0x2C53;
4554 } else {
4555 cmd = 0x2C51;
4556 }
4557 break;
4558 case 6:
4559 if (j->ver.low == 0x12) {
4560 cmd = 0x2C63;
4561 } else {
4562 cmd = 0x2C61;
4563 }
4564 break;
4565 }
4566 if (ixj_WriteDSPCommand(cmd, j))
4567 return -1;
4568
4569 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4570 return -1;
4571
4572 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4573 return -1;
4574
4575 if (j->flags.recording) {
4576 ixj_aec_start(j, j->aec_level);
4577 }
4578
4579 return 0;
4580 }
4581
4582 static void ixj_play_stop(IXJ *j)
4583 {
4584 if(ixjdebug & 0x0002)
4585 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4586
4587 if (j->write_buffer) {
4588 kfree(j->write_buffer);
4589 j->write_buffer = NULL;
4590 j->write_buffer_size = 0;
4591 }
4592 if (j->play_mode > -1) {
4593 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4594
4595 j->play_mode = -1;
4596 }
4597 j->flags.playing = 0;
4598 }
4599
4600 static inline int get_play_level(IXJ *j)
4601 {
4602 int retval;
4603
4604 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4605 return j->ssr.high << 8 | j->ssr.low;
4606 retval = j->ssr.high << 8 | j->ssr.low;
4607 retval = (retval * 256) / 240;
4608 return retval;
4609 }
4610
4611 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4612 {
4613 unsigned int mask = 0;
4614
4615 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4616
4617 poll_wait(file_p, &(j->poll_q), wait);
4618 if (j->read_buffer_ready > 0)
4619 mask |= POLLIN | POLLRDNORM; /* readable */
4620 if (j->write_buffers_empty > 0)
4621 mask |= POLLOUT | POLLWRNORM; /* writable */
4622 if (j->ex.bytes)
4623 mask |= POLLPRI;
4624 return mask;
4625 }
4626
4627 static int ixj_play_tone(IXJ *j, char tone)
4628 {
4629 if (!j->tone_state) {
4630 if(ixjdebug & 0x0002) {
4631 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4632 }
4633 if (j->dsp.low == 0x20) {
4634 idle(j);
4635 }
4636 j->tone_start_jif = jiffies;
4637
4638 j->tone_state = 1;
4639 }
4640
4641 j->tone_index = tone;
4642 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4643 return -1;
4644
4645 return 0;
4646 }
4647
4648 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4649 {
4650 j->tone_on_time = arg;
4651
4652 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4653
4654 return -1;
4655
4656 if (ixj_WriteDSPCommand(arg, j))
4657 return -1;
4658
4659 return 0;
4660 }
4661
4662 static int SCI_WaitHighSCI(IXJ *j)
4663 {
4664 int cnt;
4665
4666 j->pld_scrr.byte = inb_p(j->XILINXbase);
4667 if (!j->pld_scrr.bits.sci) {
4668 for (cnt = 0; cnt < 10; cnt++) {
4669 udelay(32);
4670 j->pld_scrr.byte = inb_p(j->XILINXbase);
4671
4672 if ((j->pld_scrr.bits.sci))
4673 return 1;
4674 }
4675 if (ixjdebug & 0x0001)
4676 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4677 return 0;
4678 } else
4679 return 1;
4680 }
4681
4682 static int SCI_WaitLowSCI(IXJ *j)
4683 {
4684 int cnt;
4685
4686 j->pld_scrr.byte = inb_p(j->XILINXbase);
4687 if (j->pld_scrr.bits.sci) {
4688 for (cnt = 0; cnt < 10; cnt++) {
4689 udelay(32);
4690 j->pld_scrr.byte = inb_p(j->XILINXbase);
4691
4692 if (!(j->pld_scrr.bits.sci))
4693 return 1;
4694 }
4695 if (ixjdebug & 0x0001)
4696 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4697 return 0;
4698 } else
4699 return 1;
4700 }
4701
4702 static int SCI_Control(IXJ *j, int control)
4703 {
4704 switch (control) {
4705 case SCI_End:
4706 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4707
4708 j->pld_scrw.bits.c1 = 0; /* to no selection */
4709
4710 break;
4711 case SCI_Enable_DAA:
4712 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4713
4714 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4715
4716 break;
4717 case SCI_Enable_Mixer:
4718 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4719
4720 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4721
4722 break;
4723 case SCI_Enable_EEPROM:
4724 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4725
4726 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4727
4728 break;
4729 default:
4730 return 0;
4731 break;
4732 }
4733 outb_p(j->pld_scrw.byte, j->XILINXbase);
4734
4735 switch (control) {
4736 case SCI_End:
4737 return 1;
4738 break;
4739 case SCI_Enable_DAA:
4740 case SCI_Enable_Mixer:
4741 case SCI_Enable_EEPROM:
4742 if (!SCI_WaitHighSCI(j))
4743 return 0;
4744 break;
4745 default:
4746 return 0;
4747 break;
4748 }
4749 return 1;
4750 }
4751
4752 static int SCI_Prepare(IXJ *j)
4753 {
4754 if (!SCI_Control(j, SCI_End))
4755 return 0;
4756
4757 if (!SCI_WaitLowSCI(j))
4758 return 0;
4759
4760 return 1;
4761 }
4762
4763 static int ixj_get_mixer(long val, IXJ *j)
4764 {
4765 int reg = (val & 0x1F00) >> 8;
4766 return j->mix.vol[reg];
4767 }
4768
4769 static int ixj_mixer(long val, IXJ *j)
4770 {
4771 BYTES bytes;
4772
4773 bytes.high = (val & 0x1F00) >> 8;
4774 bytes.low = val & 0x00FF;
4775
4776 /* save mixer value so we can get back later on */
4777 j->mix.vol[bytes.high] = bytes.low;
4778
4779 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4780
4781 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4782
4783 SCI_Control(j, SCI_Enable_Mixer);
4784
4785 SCI_Control(j, SCI_End);
4786
4787 return 0;
4788 }
4789
4790 static int daa_load(BYTES * p_bytes, IXJ *j)
4791 {
4792 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4793 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4794 if (!SCI_Control(j, SCI_Enable_DAA))
4795 return 0;
4796 else
4797 return 1;
4798 }
4799
4800 static int ixj_daa_cr4(IXJ *j, char reg)
4801 {
4802 BYTES bytes;
4803
4804 switch (j->daa_mode) {
4805 case SOP_PU_SLEEP:
4806 bytes.high = 0x14;
4807 break;
4808 case SOP_PU_RINGING:
4809 bytes.high = 0x54;
4810 break;
4811 case SOP_PU_CONVERSATION:
4812 bytes.high = 0x94;
4813 break;
4814 case SOP_PU_PULSEDIALING:
4815 bytes.high = 0xD4;
4816 break;
4817 }
4818
4819 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4820
4821 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4822 case 0:
4823 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4824 break;
4825 case 1:
4826 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4827 break;
4828 case 2:
4829 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4830 break;
4831 case 3:
4832 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4833 break;
4834 }
4835
4836 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4837
4838 if (!daa_load(&bytes, j))
4839 return 0;
4840
4841 if (!SCI_Prepare(j))
4842 return 0;
4843
4844 return 1;
4845 }
4846
4847 static char daa_int_read(IXJ *j)
4848 {
4849 BYTES bytes;
4850
4851 if (!SCI_Prepare(j))
4852 return 0;
4853
4854 bytes.high = 0x38;
4855 bytes.low = 0x00;
4856 outb_p(bytes.high, j->XILINXbase + 0x03);
4857 outb_p(bytes.low, j->XILINXbase + 0x02);
4858
4859 if (!SCI_Control(j, SCI_Enable_DAA))
4860 return 0;
4861
4862 bytes.high = inb_p(j->XILINXbase + 0x03);
4863 bytes.low = inb_p(j->XILINXbase + 0x02);
4864 if (bytes.low != ALISDAA_ID_BYTE) {
4865 if (ixjdebug & 0x0001)
4866 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4867 return 0;
4868 }
4869 if (!SCI_Control(j, SCI_Enable_DAA))
4870 return 0;
4871 if (!SCI_Control(j, SCI_End))
4872 return 0;
4873
4874 bytes.high = inb_p(j->XILINXbase + 0x03);
4875 bytes.low = inb_p(j->XILINXbase + 0x02);
4876
4877 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4878
4879 return 1;
4880 }
4881
4882 static char daa_CR_read(IXJ *j, int cr)
4883 {
4884 IXJ_WORD wdata;
4885 BYTES bytes;
4886
4887 if (!SCI_Prepare(j))
4888 return 0;
4889
4890 switch (j->daa_mode) {
4891 case SOP_PU_SLEEP:
4892 bytes.high = 0x30 + cr;
4893 break;
4894 case SOP_PU_RINGING:
4895 bytes.high = 0x70 + cr;
4896 break;
4897 case SOP_PU_CONVERSATION:
4898 bytes.high = 0xB0 + cr;
4899 break;
4900 case SOP_PU_PULSEDIALING:
4901 bytes.high = 0xF0 + cr;
4902 break;
4903 }
4904
4905 bytes.low = 0x00;
4906
4907 outb_p(bytes.high, j->XILINXbase + 0x03);
4908 outb_p(bytes.low, j->XILINXbase + 0x02);
4909
4910 if (!SCI_Control(j, SCI_Enable_DAA))
4911 return 0;
4912
4913 bytes.high = inb_p(j->XILINXbase + 0x03);
4914 bytes.low = inb_p(j->XILINXbase + 0x02);
4915 if (bytes.low != ALISDAA_ID_BYTE) {
4916 if (ixjdebug & 0x0001)
4917 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4918 return 0;
4919 }
4920 if (!SCI_Control(j, SCI_Enable_DAA))
4921 return 0;
4922 if (!SCI_Control(j, SCI_End))
4923 return 0;
4924
4925 wdata.word = inw_p(j->XILINXbase + 0x02);
4926
4927 switch(cr){
4928 case 5:
4929 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4930 break;
4931 case 4:
4932 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4933 break;
4934 case 3:
4935 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4936 break;
4937 case 2:
4938 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4939 break;
4940 case 1:
4941 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4942 break;
4943 case 0:
4944 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4945 break;
4946 default:
4947 return 0;
4948 }
4949 return 1;
4950 }
4951
4952 static int ixj_daa_cid_reset(IXJ *j)
4953 {
4954 int i;
4955 BYTES bytes;
4956
4957 if (ixjdebug & 0x0002)
4958 printk("DAA Clearing CID ram\n");
4959
4960 if (!SCI_Prepare(j))
4961 return 0;
4962
4963 bytes.high = 0x58;
4964 bytes.low = 0x00;
4965 outb_p(bytes.high, j->XILINXbase + 0x03);
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 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4975 bytes.high = bytes.low = 0x00;
4976 outb_p(bytes.high, j->XILINXbase + 0x03);
4977
4978 if (i < ALISDAA_CALLERID_SIZE - 1)
4979 outb_p(bytes.low, j->XILINXbase + 0x02);
4980
4981 if (!SCI_Control(j, SCI_Enable_DAA))
4982 return 0;
4983
4984 if (!SCI_WaitHighSCI(j))
4985 return 0;
4986
4987 }
4988
4989 if (!SCI_Control(j, SCI_End))
4990 return 0;
4991
4992 if (ixjdebug & 0x0002)
4993 printk("DAA CID ram cleared\n");
4994
4995 return 1;
4996 }
4997
4998 static int ixj_daa_cid_read(IXJ *j)
4999 {
5000 int i;
5001 BYTES bytes;
5002 char CID[ALISDAA_CALLERID_SIZE], mContinue;
5003 char *pIn, *pOut;
5004
5005 if (!SCI_Prepare(j))
5006 return 0;
5007
5008 bytes.high = 0x78;
5009 bytes.low = 0x00;
5010 outb_p(bytes.high, j->XILINXbase + 0x03);
5011 outb_p(bytes.low, j->XILINXbase + 0x02);
5012
5013 if (!SCI_Control(j, SCI_Enable_DAA))
5014 return 0;
5015
5016 if (!SCI_WaitHighSCI(j))
5017 return 0;
5018
5019 bytes.high = inb_p(j->XILINXbase + 0x03);
5020 bytes.low = inb_p(j->XILINXbase + 0x02);
5021 if (bytes.low != ALISDAA_ID_BYTE) {
5022 if (ixjdebug & 0x0001)
5023 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5024 return 0;
5025 }
5026 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5027 bytes.high = bytes.low = 0x00;
5028 outb_p(bytes.high, j->XILINXbase + 0x03);
5029 outb_p(bytes.low, j->XILINXbase + 0x02);
5030
5031 if (!SCI_Control(j, SCI_Enable_DAA))
5032 return 0;
5033
5034 if (!SCI_WaitHighSCI(j))
5035 return 0;
5036
5037 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5038 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5039 }
5040
5041 if (!SCI_Control(j, SCI_End))
5042 return 0;
5043
5044 pIn = CID;
5045 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5046 mContinue = 1;
5047 while (mContinue) {
5048 if ((pIn[1] & 0x03) == 0x01) {
5049 pOut[0] = pIn[0];
5050 }
5051 if ((pIn[2] & 0x0c) == 0x04) {
5052 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5053 }
5054 if ((pIn[3] & 0x30) == 0x10) {
5055 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5056 }
5057 if ((pIn[4] & 0xc0) == 0x40) {
5058 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5059 } else {
5060 mContinue = FALSE;
5061 }
5062 pIn += 5, pOut += 4;
5063 }
5064 memset(&j->cid, 0, sizeof(PHONE_CID));
5065 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5066 pOut += 4;
5067 strncpy(j->cid.month, pOut, 2);
5068 pOut += 2;
5069 strncpy(j->cid.day, pOut, 2);
5070 pOut += 2;
5071 strncpy(j->cid.hour, pOut, 2);
5072 pOut += 2;
5073 strncpy(j->cid.min, pOut, 2);
5074 pOut += 3;
5075 j->cid.numlen = *pOut;
5076 pOut += 1;
5077 strncpy(j->cid.number, pOut, j->cid.numlen);
5078 pOut += j->cid.numlen + 1;
5079 j->cid.namelen = *pOut;
5080 pOut += 1;
5081 strncpy(j->cid.name, pOut, j->cid.namelen);
5082
5083 ixj_daa_cid_reset(j);
5084 return 1;
5085 }
5086
5087 static char daa_get_version(IXJ *j)
5088 {
5089 BYTES bytes;
5090
5091 if (!SCI_Prepare(j))
5092 return 0;
5093
5094 bytes.high = 0x35;
5095 bytes.low = 0x00;
5096 outb_p(bytes.high, j->XILINXbase + 0x03);
5097 outb_p(bytes.low, j->XILINXbase + 0x02);
5098
5099 if (!SCI_Control(j, SCI_Enable_DAA))
5100 return 0;
5101
5102 bytes.high = inb_p(j->XILINXbase + 0x03);
5103 bytes.low = inb_p(j->XILINXbase + 0x02);
5104 if (bytes.low != ALISDAA_ID_BYTE) {
5105 if (ixjdebug & 0x0001)
5106 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5107 return 0;
5108 }
5109 if (!SCI_Control(j, SCI_Enable_DAA))
5110 return 0;
5111
5112 if (!SCI_Control(j, SCI_End))
5113 return 0;
5114
5115 bytes.high = inb_p(j->XILINXbase + 0x03);
5116 bytes.low = inb_p(j->XILINXbase + 0x02);
5117 if (ixjdebug & 0x0002)
5118 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5119 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5120 return bytes.high;
5121 }
5122
5123 static int daa_set_mode(IXJ *j, int mode)
5124 {
5125 /* NOTE:
5126 The DAA *MUST* be in the conversation mode if the
5127 PSTN line is to be seized (PSTN line off-hook).
5128 Taking the PSTN line off-hook while the DAA is in
5129 a mode other than conversation mode will cause a
5130 hardware failure of the ALIS-A part.
5131
5132 NOTE:
5133 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5134 if the PSTN line is on-hook. Failure to have the PSTN line
5135 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5136 ALIS-A part.
5137 */
5138
5139 BYTES bytes;
5140
5141 j->flags.pstn_rmr = 0;
5142
5143 if (!SCI_Prepare(j))
5144 return 0;
5145
5146 switch (mode) {
5147 case SOP_PU_RESET:
5148 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5149
5150 outb_p(j->pld_scrw.byte, j->XILINXbase);
5151 j->pld_slicw.bits.rly2 = 0;
5152 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5153 bytes.high = 0x10;
5154 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5155 daa_load(&bytes, j);
5156 if (!SCI_Prepare(j))
5157 return 0;
5158
5159 j->daa_mode = SOP_PU_SLEEP;
5160 break;
5161 case SOP_PU_SLEEP:
5162 if(j->daa_mode == SOP_PU_SLEEP)
5163 {
5164 break;
5165 }
5166 if (ixjdebug & 0x0008)
5167 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5168 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5169 {
5170 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5171
5172 outb_p(j->pld_scrw.byte, j->XILINXbase);
5173 j->pld_slicw.bits.rly2 = 0;
5174 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5175 bytes.high = 0x10;
5176 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5177 daa_load(&bytes, j);
5178 if (!SCI_Prepare(j))
5179 return 0;
5180 }
5181 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5182
5183 outb_p(j->pld_scrw.byte, j->XILINXbase);
5184 j->pld_slicw.bits.rly2 = 0;
5185 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5186 bytes.high = 0x10;
5187 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5188 daa_load(&bytes, j);
5189 if (!SCI_Prepare(j))
5190 return 0;
5191
5192 j->daa_mode = SOP_PU_SLEEP;
5193 j->flags.pstn_ringing = 0;
5194 j->ex.bits.pstn_ring = 0;
5195 j->pstn_sleeptil = jiffies + (hertz / 4);
5196 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5197 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5198 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5199 break;
5200 case SOP_PU_RINGING:
5201 if (ixjdebug & 0x0008)
5202 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5203 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5204
5205 outb_p(j->pld_scrw.byte, j->XILINXbase);
5206 j->pld_slicw.bits.rly2 = 0;
5207 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5208 bytes.high = 0x50;
5209 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5210 daa_load(&bytes, j);
5211 if (!SCI_Prepare(j))
5212 return 0;
5213 j->daa_mode = SOP_PU_RINGING;
5214 break;
5215 case SOP_PU_CONVERSATION:
5216 if (ixjdebug & 0x0008)
5217 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5218 bytes.high = 0x90;
5219 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5220 daa_load(&bytes, j);
5221 if (!SCI_Prepare(j))
5222 return 0;
5223 j->pld_slicw.bits.rly2 = 1;
5224 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5225 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5226
5227 outb_p(j->pld_scrw.byte, j->XILINXbase);
5228 j->daa_mode = SOP_PU_CONVERSATION;
5229 j->flags.pstn_ringing = 0;
5230 j->ex.bits.pstn_ring = 0;
5231 j->pstn_sleeptil = jiffies;
5232 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5233 break;
5234 case SOP_PU_PULSEDIALING:
5235 if (ixjdebug & 0x0008)
5236 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5237 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5238
5239 outb_p(j->pld_scrw.byte, j->XILINXbase);
5240 j->pld_slicw.bits.rly2 = 0;
5241 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5242 bytes.high = 0xD0;
5243 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5244 daa_load(&bytes, j);
5245 if (!SCI_Prepare(j))
5246 return 0;
5247 j->daa_mode = SOP_PU_PULSEDIALING;
5248 break;
5249 default:
5250 break;
5251 }
5252 return 1;
5253 }
5254
5255 static int ixj_daa_write(IXJ *j)
5256 {
5257 BYTES bytes;
5258
5259 j->flags.pstncheck = 1;
5260
5261 daa_set_mode(j, SOP_PU_SLEEP);
5262
5263 if (!SCI_Prepare(j))
5264 return 0;
5265
5266 outb_p(j->pld_scrw.byte, j->XILINXbase);
5267
5268 bytes.high = 0x14;
5269 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5270 if (!daa_load(&bytes, j))
5271 return 0;
5272
5273 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5274 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5275 if (!daa_load(&bytes, j))
5276 return 0;
5277
5278 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5279 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5280 if (!daa_load(&bytes, j))
5281 return 0;
5282
5283 if (!SCI_Prepare(j))
5284 return 0;
5285
5286 bytes.high = 0x1F;
5287 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5288 if (!daa_load(&bytes, j))
5289 return 0;
5290
5291 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5292 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5293 if (!daa_load(&bytes, j))
5294 return 0;
5295
5296 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5297 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5298 if (!daa_load(&bytes, j))
5299 return 0;
5300
5301 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5302 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5303 if (!daa_load(&bytes, j))
5304 return 0;
5305
5306 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5307 bytes.low = 0x00;
5308 if (!daa_load(&bytes, j))
5309 return 0;
5310
5311 if (!SCI_Prepare(j))
5312 return 0;
5313
5314 bytes.high = 0x00;
5315 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5316 if (!daa_load(&bytes, j))
5317 return 0;
5318
5319 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5320 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5321 if (!daa_load(&bytes, j))
5322 return 0;
5323
5324 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5325 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5326 if (!daa_load(&bytes, j))
5327 return 0;
5328
5329 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5330 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5331 if (!daa_load(&bytes, j))
5332 return 0;
5333
5334 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5335 bytes.low = 0x00;
5336 if (!daa_load(&bytes, j))
5337 return 0;
5338
5339 if (!SCI_Control(j, SCI_End))
5340 return 0;
5341 if (!SCI_WaitLowSCI(j))
5342 return 0;
5343
5344 bytes.high = 0x01;
5345 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5346 if (!daa_load(&bytes, j))
5347 return 0;
5348
5349 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5350 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5351 if (!daa_load(&bytes, j))
5352 return 0;
5353
5354 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5355 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5356 if (!daa_load(&bytes, j))
5357 return 0;
5358
5359 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5360 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5361 if (!daa_load(&bytes, j))
5362 return 0;
5363
5364 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5365 bytes.low = 0x00;
5366 if (!daa_load(&bytes, j))
5367 return 0;
5368
5369 if (!SCI_Control(j, SCI_End))
5370 return 0;
5371 if (!SCI_WaitLowSCI(j))
5372 return 0;
5373
5374 bytes.high = 0x02;
5375 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5376 if (!daa_load(&bytes, j))
5377 return 0;
5378
5379 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5380 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5381 if (!daa_load(&bytes, j))
5382 return 0;
5383
5384 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5385 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5386 if (!daa_load(&bytes, j))
5387 return 0;
5388
5389 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5390 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5391 if (!daa_load(&bytes, j))
5392 return 0;
5393
5394 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5395 bytes.low = 0x00;
5396 if (!daa_load(&bytes, j))
5397 return 0;
5398
5399 if (!SCI_Control(j, SCI_End))
5400 return 0;
5401 if (!SCI_WaitLowSCI(j))
5402 return 0;
5403
5404 bytes.high = 0x03;
5405 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5406 if (!daa_load(&bytes, j))
5407 return 0;
5408
5409 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5410 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5411 if (!daa_load(&bytes, j))
5412 return 0;
5413
5414 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5415 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5416 if (!daa_load(&bytes, j))
5417 return 0;
5418
5419 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5420 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5421 if (!daa_load(&bytes, j))
5422 return 0;
5423
5424 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5425 bytes.low = 0x00;
5426 if (!daa_load(&bytes, j))
5427 return 0;
5428
5429 if (!SCI_Control(j, SCI_End))
5430 return 0;
5431 if (!SCI_WaitLowSCI(j))
5432 return 0;
5433
5434 bytes.high = 0x04;
5435 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5436 if (!daa_load(&bytes, j))
5437 return 0;
5438
5439 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5440 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5441 if (!daa_load(&bytes, j))
5442 return 0;
5443
5444 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5445 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5446 if (!daa_load(&bytes, j))
5447 return 0;
5448
5449 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5450 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5451 if (!daa_load(&bytes, j))
5452 return 0;
5453
5454 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5455 bytes.low = 0x00;
5456 if (!daa_load(&bytes, j))
5457 return 0;
5458
5459 if (!SCI_Control(j, SCI_End))
5460 return 0;
5461 if (!SCI_WaitLowSCI(j))
5462 return 0;
5463
5464 bytes.high = 0x05;
5465 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5466 if (!daa_load(&bytes, j))
5467 return 0;
5468
5469 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5470 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5471 if (!daa_load(&bytes, j))
5472 return 0;
5473
5474 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5475 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5476 if (!daa_load(&bytes, j))
5477 return 0;
5478
5479 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5480 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5481 if (!daa_load(&bytes, j))
5482 return 0;
5483
5484 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5485 bytes.low = 0x00;
5486 if (!daa_load(&bytes, j))
5487 return 0;
5488
5489 if (!SCI_Control(j, SCI_End))
5490 return 0;
5491 if (!SCI_WaitLowSCI(j))
5492 return 0;
5493
5494 bytes.high = 0x06;
5495 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5496 if (!daa_load(&bytes, j))
5497 return 0;
5498
5499 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5500 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5501 if (!daa_load(&bytes, j))
5502 return 0;
5503
5504 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5505 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5506 if (!daa_load(&bytes, j))
5507 return 0;
5508
5509 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5510 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5511 if (!daa_load(&bytes, j))
5512 return 0;
5513
5514 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5515 bytes.low = 0x00;
5516 if (!daa_load(&bytes, j))
5517 return 0;
5518
5519 if (!SCI_Control(j, SCI_End))
5520 return 0;
5521 if (!SCI_WaitLowSCI(j))
5522 return 0;
5523
5524 bytes.high = 0x07;
5525 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5526 if (!daa_load(&bytes, j))
5527 return 0;
5528
5529 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5530 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5531 if (!daa_load(&bytes, j))
5532 return 0;
5533
5534 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5535 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5536 if (!daa_load(&bytes, j))
5537 return 0;
5538
5539 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5540 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5541 if (!daa_load(&bytes, j))
5542 return 0;
5543
5544 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5545 bytes.low = 0x00;
5546 if (!daa_load(&bytes, j))
5547 return 0;
5548
5549 if (!SCI_Control(j, SCI_End))
5550 return 0;
5551 if (!SCI_WaitLowSCI(j))
5552 return 0;
5553
5554 bytes.high = 0x08;
5555 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5556 if (!daa_load(&bytes, j))
5557 return 0;
5558
5559 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5560 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5561 if (!daa_load(&bytes, j))
5562 return 0;
5563
5564 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5565 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5566 if (!daa_load(&bytes, j))
5567 return 0;
5568
5569 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5570 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5571 if (!daa_load(&bytes, j))
5572 return 0;
5573
5574 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5575 bytes.low = 0x00;
5576 if (!daa_load(&bytes, j))
5577 return 0;
5578
5579 if (!SCI_Control(j, SCI_End))
5580 return 0;
5581 if (!SCI_WaitLowSCI(j))
5582 return 0;
5583
5584 bytes.high = 0x09;
5585 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5586 if (!daa_load(&bytes, j))
5587 return 0;
5588
5589 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5590 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5591 if (!daa_load(&bytes, j))
5592 return 0;
5593
5594 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5595 bytes.low = 0x00;
5596 if (!daa_load(&bytes, j))
5597 return 0;
5598
5599 if (!SCI_Control(j, SCI_End))
5600 return 0;
5601 if (!SCI_WaitLowSCI(j))
5602 return 0;
5603
5604 bytes.high = 0x0A;
5605 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5606 if (!daa_load(&bytes, j))
5607 return 0;
5608
5609 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5610 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5611 if (!daa_load(&bytes, j))
5612 return 0;
5613
5614 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5615 bytes.low = 0x00;
5616 if (!daa_load(&bytes, j))
5617 return 0;
5618
5619 if (!SCI_Control(j, SCI_End))
5620 return 0;
5621 if (!SCI_WaitLowSCI(j))
5622 return 0;
5623
5624 bytes.high = 0x0B;
5625 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5626 if (!daa_load(&bytes, j))
5627 return 0;
5628
5629 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5630 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5631 if (!daa_load(&bytes, j))
5632 return 0;
5633
5634 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5635 bytes.low = 0x00;
5636 if (!daa_load(&bytes, j))
5637 return 0;
5638
5639 if (!SCI_Control(j, SCI_End))
5640 return 0;
5641 if (!SCI_WaitLowSCI(j))
5642 return 0;
5643
5644 bytes.high = 0x0C;
5645 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5646 if (!daa_load(&bytes, j))
5647 return 0;
5648
5649 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5650 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5651 if (!daa_load(&bytes, j))
5652 return 0;
5653
5654 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5655 bytes.low = 0x00;
5656 if (!daa_load(&bytes, j))
5657 return 0;
5658
5659 if (!SCI_Control(j, SCI_End))
5660 return 0;
5661 if (!SCI_WaitLowSCI(j))
5662 return 0;
5663
5664 bytes.high = 0x0D;
5665 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5666 if (!daa_load(&bytes, j))
5667 return 0;
5668
5669 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5670 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5671 if (!daa_load(&bytes, j))
5672 return 0;
5673
5674 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5675 bytes.low = 0x00;
5676 if (!daa_load(&bytes, j))
5677 return 0;
5678
5679 if (!SCI_Control(j, SCI_End))
5680 return 0;
5681 if (!SCI_WaitLowSCI(j))
5682 return 0;
5683
5684 bytes.high = 0x0E;
5685 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5686 if (!daa_load(&bytes, j))
5687 return 0;
5688
5689 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5690 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5691 if (!daa_load(&bytes, j))
5692 return 0;
5693
5694 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5695 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5696 if (!daa_load(&bytes, j))
5697 return 0;
5698
5699 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5700 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5701 if (!daa_load(&bytes, j))
5702 return 0;
5703
5704 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5705 bytes.low = 0x00;
5706 if (!daa_load(&bytes, j))
5707 return 0;
5708
5709 if (!SCI_Control(j, SCI_End))
5710 return 0;
5711 if (!SCI_WaitLowSCI(j))
5712 return 0;
5713
5714 bytes.high = 0x0F;
5715 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5716 if (!daa_load(&bytes, j))
5717 return 0;
5718
5719 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5720 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5721 if (!daa_load(&bytes, j))
5722 return 0;
5723
5724 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5725 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5726 if (!daa_load(&bytes, j))
5727 return 0;
5728
5729 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5730 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5731 if (!daa_load(&bytes, j))
5732 return 0;
5733
5734 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5735 bytes.low = 0x00;
5736 if (!daa_load(&bytes, j))
5737 return 0;
5738
5739 udelay(32);
5740 j->pld_scrr.byte = inb_p(j->XILINXbase);
5741 if (!SCI_Control(j, SCI_End))
5742 return 0;
5743
5744 outb_p(j->pld_scrw.byte, j->XILINXbase);
5745
5746 if (ixjdebug & 0x0002)
5747 printk("DAA Coefficients Loaded\n");
5748
5749 j->flags.pstncheck = 0;
5750 return 1;
5751 }
5752
5753 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5754 {
5755 j->tone_off_time = arg;
5756 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5757
5758 return -1;
5759 if (ixj_WriteDSPCommand(arg, j))
5760 return -1;
5761 return 0;
5762 }
5763
5764 static int ixj_get_tone_on(IXJ *j)
5765 {
5766 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5767
5768 return -1;
5769 return 0;
5770 }
5771
5772 static int ixj_get_tone_off(IXJ *j)
5773 {
5774 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5775
5776 return -1;
5777 return 0;
5778 }
5779
5780 static void ixj_busytone(IXJ *j)
5781 {
5782 j->flags.ringback = 0;
5783 j->flags.dialtone = 0;
5784 j->flags.busytone = 1;
5785 ixj_set_tone_on(0x07D0, j);
5786 ixj_set_tone_off(0x07D0, j);
5787 ixj_play_tone(j, 27);
5788 }
5789
5790 static void ixj_dialtone(IXJ *j)
5791 {
5792 j->flags.ringback = 0;
5793 j->flags.dialtone = 1;
5794 j->flags.busytone = 0;
5795 if (j->dsp.low == 0x20) {
5796 return;
5797 } else {
5798 ixj_set_tone_on(0xFFFF, j);
5799 ixj_set_tone_off(0x0000, j);
5800 ixj_play_tone(j, 25);
5801 }
5802 }
5803
5804 static void ixj_cpt_stop(IXJ *j)
5805 {
5806 if(j->tone_state || j->tone_cadence_state)
5807 {
5808 j->flags.dialtone = 0;
5809 j->flags.busytone = 0;
5810 j->flags.ringback = 0;
5811 ixj_set_tone_on(0x0001, j);
5812 ixj_set_tone_off(0x0000, j);
5813 ixj_play_tone(j, 0);
5814 j->tone_state = j->tone_cadence_state = 0;
5815 if (j->cadence_t) {
5816 if (j->cadence_t->ce) {
5817 kfree(j->cadence_t->ce);
5818 }
5819 kfree(j->cadence_t);
5820 j->cadence_t = NULL;
5821 }
5822 }
5823 if (j->play_mode == -1 && j->rec_mode == -1)
5824 idle(j);
5825 if (j->play_mode != -1 && j->dsp.low == 0x20)
5826 ixj_play_start(j);
5827 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5828 ixj_record_start(j);
5829 }
5830
5831 static void ixj_ringback(IXJ *j)
5832 {
5833 j->flags.busytone = 0;
5834 j->flags.dialtone = 0;
5835 j->flags.ringback = 1;
5836 ixj_set_tone_on(0x0FA0, j);
5837 ixj_set_tone_off(0x2EE0, j);
5838 ixj_play_tone(j, 26);
5839 }
5840
5841 static void ixj_testram(IXJ *j)
5842 {
5843 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5844 }
5845
5846 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5847 {
5848 ixj_cadence *lcp;
5849 IXJ_CADENCE_ELEMENT __user *cep;
5850 IXJ_CADENCE_ELEMENT *lcep;
5851 IXJ_TONE ti;
5852 int err;
5853
5854 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5855 if (lcp == NULL)
5856 return -ENOMEM;
5857
5858 err = -EFAULT;
5859 if (copy_from_user(&lcp->elements_used,
5860 &cp->elements_used, sizeof(int)))
5861 goto out;
5862 if (copy_from_user(&lcp->termination,
5863 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5864 goto out;
5865 if (get_user(cep, &cp->ce))
5866 goto out;
5867
5868 err = -EINVAL;
5869 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5870 goto out;
5871
5872 err = -ENOMEM;
5873 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5874 if (!lcep)
5875 goto out;
5876
5877 err = -EFAULT;
5878 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5879 goto out1;
5880
5881 if (j->cadence_t) {
5882 kfree(j->cadence_t->ce);
5883 kfree(j->cadence_t);
5884 }
5885 lcp->ce = (void *) lcep;
5886 j->cadence_t = lcp;
5887 j->tone_cadence_state = 0;
5888 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5889 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5890 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5891 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5892 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5893 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5894 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5895 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5896 ixj_init_tone(j, &ti);
5897 }
5898 ixj_play_tone(j, lcp->ce[0].index);
5899 return 1;
5900 out1:
5901 kfree(lcep);
5902 out:
5903 kfree(lcp);
5904 return err;
5905 }
5906
5907 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5908 {
5909 IXJ_FILTER_CADENCE *lcp;
5910 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5911 if (lcp == NULL) {
5912 if(ixjdebug & 0x0001) {
5913 printk(KERN_INFO "Could not allocate memory for cadence\n");
5914 }
5915 return -ENOMEM;
5916 }
5917 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5918 if(ixjdebug & 0x0001) {
5919 printk(KERN_INFO "Could not copy cadence to kernel\n");
5920 }
5921 kfree(lcp);
5922 return -EFAULT;
5923 }
5924 if (lcp->filter > 5) {
5925 if(ixjdebug & 0x0001) {
5926 printk(KERN_INFO "Cadence out of range\n");
5927 }
5928 kfree(lcp);
5929 return -1;
5930 }
5931 j->cadence_f[lcp->filter].state = 0;
5932 j->cadence_f[lcp->filter].enable = lcp->enable;
5933 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5934 j->cadence_f[lcp->filter].on1 = lcp->on1;
5935 j->cadence_f[lcp->filter].on1min = 0;
5936 j->cadence_f[lcp->filter].on1max = 0;
5937 j->cadence_f[lcp->filter].off1 = lcp->off1;
5938 j->cadence_f[lcp->filter].off1min = 0;
5939 j->cadence_f[lcp->filter].off1max = 0;
5940 j->cadence_f[lcp->filter].on2 = lcp->on2;
5941 j->cadence_f[lcp->filter].on2min = 0;
5942 j->cadence_f[lcp->filter].on2max = 0;
5943 j->cadence_f[lcp->filter].off2 = lcp->off2;
5944 j->cadence_f[lcp->filter].off2min = 0;
5945 j->cadence_f[lcp->filter].off2max = 0;
5946 j->cadence_f[lcp->filter].on3 = lcp->on3;
5947 j->cadence_f[lcp->filter].on3min = 0;
5948 j->cadence_f[lcp->filter].on3max = 0;
5949 j->cadence_f[lcp->filter].off3 = lcp->off3;
5950 j->cadence_f[lcp->filter].off3min = 0;
5951 j->cadence_f[lcp->filter].off3max = 0;
5952 if(ixjdebug & 0x0002) {
5953 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5954 }
5955 kfree(lcp);
5956 return 0;
5957 }
5958
5959 static void add_caps(IXJ *j)
5960 {
5961 j->caps = 0;
5962 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5963 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5964 j->caplist[j->caps].captype = vendor;
5965 j->caplist[j->caps].handle = j->caps++;
5966 j->caplist[j->caps].captype = device;
5967 switch (j->cardtype) {
5968 case QTI_PHONEJACK:
5969 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5970 break;
5971 case QTI_LINEJACK:
5972 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5973 break;
5974 case QTI_PHONEJACK_LITE:
5975 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5976 break;
5977 case QTI_PHONEJACK_PCI:
5978 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5979 break;
5980 case QTI_PHONECARD:
5981 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5982 break;
5983 }
5984 j->caplist[j->caps].cap = j->cardtype;
5985 j->caplist[j->caps].handle = j->caps++;
5986 strcpy(j->caplist[j->caps].desc, "POTS");
5987 j->caplist[j->caps].captype = port;
5988 j->caplist[j->caps].cap = pots;
5989 j->caplist[j->caps].handle = j->caps++;
5990
5991 /* add devices that can do speaker/mic */
5992 switch (j->cardtype) {
5993 case QTI_PHONEJACK:
5994 case QTI_LINEJACK:
5995 case QTI_PHONEJACK_PCI:
5996 case QTI_PHONECARD:
5997 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5998 j->caplist[j->caps].captype = port;
5999 j->caplist[j->caps].cap = speaker;
6000 j->caplist[j->caps].handle = j->caps++;
6001 default:
6002 break;
6003 }
6004
6005 /* add devices that can do handset */
6006 switch (j->cardtype) {
6007 case QTI_PHONEJACK:
6008 strcpy(j->caplist[j->caps].desc, "HANDSET");
6009 j->caplist[j->caps].captype = port;
6010 j->caplist[j->caps].cap = handset;
6011 j->caplist[j->caps].handle = j->caps++;
6012 break;
6013 default:
6014 break;
6015 }
6016
6017 /* add devices that can do PSTN */
6018 switch (j->cardtype) {
6019 case QTI_LINEJACK:
6020 strcpy(j->caplist[j->caps].desc, "PSTN");
6021 j->caplist[j->caps].captype = port;
6022 j->caplist[j->caps].cap = pstn;
6023 j->caplist[j->caps].handle = j->caps++;
6024 break;
6025 default:
6026 break;
6027 }
6028
6029 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6030 strcpy(j->caplist[j->caps].desc, "ULAW");
6031 j->caplist[j->caps].captype = codec;
6032 j->caplist[j->caps].cap = ULAW;
6033 j->caplist[j->caps].handle = j->caps++;
6034
6035 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6036 j->caplist[j->caps].captype = codec;
6037 j->caplist[j->caps].cap = LINEAR16;
6038 j->caplist[j->caps].handle = j->caps++;
6039
6040 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6041 j->caplist[j->caps].captype = codec;
6042 j->caplist[j->caps].cap = LINEAR8;
6043 j->caplist[j->caps].handle = j->caps++;
6044
6045 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6046 j->caplist[j->caps].captype = codec;
6047 j->caplist[j->caps].cap = WSS;
6048 j->caplist[j->caps].handle = j->caps++;
6049
6050 /* software ALAW codec, made from ULAW */
6051 strcpy(j->caplist[j->caps].desc, "ALAW");
6052 j->caplist[j->caps].captype = codec;
6053 j->caplist[j->caps].cap = ALAW;
6054 j->caplist[j->caps].handle = j->caps++;
6055
6056 /* version 12 of the 8020 does the following codecs in a broken way */
6057 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6058 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6059 j->caplist[j->caps].captype = codec;
6060 j->caplist[j->caps].cap = G723_63;
6061 j->caplist[j->caps].handle = j->caps++;
6062
6063 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6064 j->caplist[j->caps].captype = codec;
6065 j->caplist[j->caps].cap = G723_53;
6066 j->caplist[j->caps].handle = j->caps++;
6067
6068 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6069 j->caplist[j->caps].captype = codec;
6070 j->caplist[j->caps].cap = TS48;
6071 j->caplist[j->caps].handle = j->caps++;
6072
6073 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6074 j->caplist[j->caps].captype = codec;
6075 j->caplist[j->caps].cap = TS41;
6076 j->caplist[j->caps].handle = j->caps++;
6077 }
6078
6079 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6080 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6081 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6082 j->caplist[j->caps].captype = codec;
6083 j->caplist[j->caps].cap = TS85;
6084 j->caplist[j->caps].handle = j->caps++;
6085 }
6086
6087 /* 8021 chips can do G728 */
6088 if (j->dsp.low == 0x21) {
6089 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6090 j->caplist[j->caps].captype = codec;
6091 j->caplist[j->caps].cap = G728;
6092 j->caplist[j->caps].handle = j->caps++;
6093 }
6094
6095 /* 8021/8022 chips can do G729 if loaded */
6096 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6097 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6098 j->caplist[j->caps].captype = codec;
6099 j->caplist[j->caps].cap = G729;
6100 j->caplist[j->caps].handle = j->caps++;
6101 }
6102 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6103 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6104 j->caplist[j->caps].captype = codec;
6105 j->caplist[j->caps].cap = G729B;
6106 j->caplist[j->caps].handle = j->caps++;
6107 }
6108 }
6109
6110 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6111 {
6112 int cnt;
6113 int retval = 0;
6114 for (cnt = 0; cnt < j->caps; cnt++) {
6115 if (pcreq->captype == j->caplist[cnt].captype
6116 && pcreq->cap == j->caplist[cnt].cap) {
6117 retval = 1;
6118 break;
6119 }
6120 }
6121 return retval;
6122 }
6123
6124 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6125 {
6126 IXJ_TONE ti;
6127 IXJ_FILTER jf;
6128 IXJ_FILTER_RAW jfr;
6129 void __user *argp = (void __user *)arg;
6130
6131 unsigned int raise, mant;
6132 unsigned int minor = iminor(inode);
6133 int board = NUM(inode);
6134
6135 IXJ *j = get_ixj(NUM(inode));
6136
6137 int retval = 0;
6138
6139 /*
6140 * Set up locks to ensure that only one process is talking to the DSP at a time.
6141 * This is necessary to keep the DSP from locking up.
6142 */
6143 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6144 set_current_state(TASK_INTERRUPTIBLE);
6145 schedule_timeout(1);
6146 }
6147 if (ixjdebug & 0x0040)
6148 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6149 if (minor >= IXJMAX) {
6150 clear_bit(board, &j->busyflags);
6151 return -ENODEV;
6152 }
6153 /*
6154 * Check ioctls only root can use.
6155 */
6156 if (!capable(CAP_SYS_ADMIN)) {
6157 switch (cmd) {
6158 case IXJCTL_TESTRAM:
6159 case IXJCTL_HZ:
6160 retval = -EPERM;
6161 }
6162 }
6163 switch (cmd) {
6164 case IXJCTL_TESTRAM:
6165 ixj_testram(j);
6166 retval = (j->ssr.high << 8) + j->ssr.low;
6167 break;
6168 case IXJCTL_CARDTYPE:
6169 retval = j->cardtype;
6170 break;
6171 case IXJCTL_SERIAL:
6172 retval = j->serial;
6173 break;
6174 case IXJCTL_VERSION:
6175 if (copy_to_user(argp, ixj_c_revision, strlen(ixj_c_revision)))
6176 retval = -EFAULT;
6177 break;
6178 case PHONE_RING_CADENCE:
6179 j->ring_cadence = arg;
6180 break;
6181 case IXJCTL_CIDCW:
6182 if(arg) {
6183 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6184 retval = -EFAULT;
6185 break;
6186 }
6187 } else {
6188 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6189 }
6190 ixj_write_cidcw(j);
6191 break;
6192 /* Binary compatbility */
6193 case OLD_PHONE_RING_START:
6194 arg = 0;
6195 /* Fall through */
6196 case PHONE_RING_START:
6197 if(arg) {
6198 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6199 retval = -EFAULT;
6200 break;
6201 }
6202 ixj_write_cid(j);
6203 } else {
6204 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6205 }
6206 ixj_ring_start(j);
6207 break;
6208 case PHONE_RING_STOP:
6209 j->flags.cringing = 0;
6210 if(j->cadence_f[5].enable) {
6211 j->cadence_f[5].state = 0;
6212 }
6213 ixj_ring_off(j);
6214 break;
6215 case PHONE_RING:
6216 retval = ixj_ring(j);
6217 break;
6218 case PHONE_EXCEPTION:
6219 retval = j->ex.bytes;
6220 if(j->ex.bits.flash) {
6221 j->flash_end = 0;
6222 j->ex.bits.flash = 0;
6223 }
6224 j->ex.bits.pstn_ring = 0;
6225 j->ex.bits.caller_id = 0;
6226 j->ex.bits.pstn_wink = 0;
6227 j->ex.bits.f0 = 0;
6228 j->ex.bits.f1 = 0;
6229 j->ex.bits.f2 = 0;
6230 j->ex.bits.f3 = 0;
6231 j->ex.bits.fc0 = 0;
6232 j->ex.bits.fc1 = 0;
6233 j->ex.bits.fc2 = 0;
6234 j->ex.bits.fc3 = 0;
6235 j->ex.bits.reserved = 0;
6236 break;
6237 case PHONE_HOOKSTATE:
6238 j->ex.bits.hookstate = 0;
6239 retval = j->hookstate; //j->r_hook;
6240 break;
6241 case IXJCTL_SET_LED:
6242 LED_SetState(arg, j);
6243 break;
6244 case PHONE_FRAME:
6245 retval = set_base_frame(j, arg);
6246 break;
6247 case PHONE_REC_CODEC:
6248 retval = set_rec_codec(j, arg);
6249 break;
6250 case PHONE_VAD:
6251 ixj_vad(j, arg);
6252 break;
6253 case PHONE_REC_START:
6254 ixj_record_start(j);
6255 break;
6256 case PHONE_REC_STOP:
6257 ixj_record_stop(j);
6258 break;
6259 case PHONE_REC_DEPTH:
6260 set_rec_depth(j, arg);
6261 break;
6262 case PHONE_REC_VOLUME:
6263 if(arg == -1) {
6264 retval = get_rec_volume(j);
6265 }
6266 else {
6267 set_rec_volume(j, arg);
6268 retval = arg;
6269 }
6270 break;
6271 case PHONE_REC_VOLUME_LINEAR:
6272 if(arg == -1) {
6273 retval = get_rec_volume_linear(j);
6274 }
6275 else {
6276 set_rec_volume_linear(j, arg);
6277 retval = arg;
6278 }
6279 break;
6280 case IXJCTL_DTMF_PRESCALE:
6281 if(arg == -1) {
6282 retval = get_dtmf_prescale(j);
6283 }
6284 else {
6285 set_dtmf_prescale(j, arg);
6286 retval = arg;
6287 }
6288 break;
6289 case PHONE_REC_LEVEL:
6290 retval = get_rec_level(j);
6291 break;
6292 case IXJCTL_SC_RXG:
6293 retval = ixj_siadc(j, arg);
6294 break;
6295 case IXJCTL_SC_TXG:
6296 retval = ixj_sidac(j, arg);
6297 break;
6298 case IXJCTL_AEC_START:
6299 ixj_aec_start(j, arg);
6300 break;
6301 case IXJCTL_AEC_STOP:
6302 aec_stop(j);
6303 break;
6304 case IXJCTL_AEC_GET_LEVEL:
6305 retval = j->aec_level;
6306 break;
6307 case PHONE_PLAY_CODEC:
6308 retval = set_play_codec(j, arg);
6309 break;
6310 case PHONE_PLAY_START:
6311 retval = ixj_play_start(j);
6312 break;
6313 case PHONE_PLAY_STOP:
6314 ixj_play_stop(j);
6315 break;
6316 case PHONE_PLAY_DEPTH:
6317 set_play_depth(j, arg);
6318 break;
6319 case PHONE_PLAY_VOLUME:
6320 if(arg == -1) {
6321 retval = get_play_volume(j);
6322 }
6323 else {
6324 set_play_volume(j, arg);
6325 retval = arg;
6326 }
6327 break;
6328 case PHONE_PLAY_VOLUME_LINEAR:
6329 if(arg == -1) {
6330 retval = get_play_volume_linear(j);
6331 }
6332 else {
6333 set_play_volume_linear(j, arg);
6334 retval = arg;
6335 }
6336 break;
6337 case PHONE_PLAY_LEVEL:
6338 retval = get_play_level(j);
6339 break;
6340 case IXJCTL_DSP_TYPE:
6341 retval = (j->dsp.high << 8) + j->dsp.low;
6342 break;
6343 case IXJCTL_DSP_VERSION:
6344 retval = (j->ver.high << 8) + j->ver.low;
6345 break;
6346 case IXJCTL_HZ:
6347 hertz = arg;
6348 break;
6349 case IXJCTL_RATE:
6350 if (arg > hertz)
6351 retval = -1;
6352 else
6353 samplerate = arg;
6354 break;
6355 case IXJCTL_DRYBUFFER_READ:
6356 put_user(j->drybuffer, (unsigned long __user *) argp);
6357 break;
6358 case IXJCTL_DRYBUFFER_CLEAR:
6359 j->drybuffer = 0;
6360 break;
6361 case IXJCTL_FRAMES_READ:
6362 put_user(j->framesread, (unsigned long __user *) argp);
6363 break;
6364 case IXJCTL_FRAMES_WRITTEN:
6365 put_user(j->frameswritten, (unsigned long __user *) argp);
6366 break;
6367 case IXJCTL_READ_WAIT:
6368 put_user(j->read_wait, (unsigned long __user *) argp);
6369 break;
6370 case IXJCTL_WRITE_WAIT:
6371 put_user(j->write_wait, (unsigned long __user *) argp);
6372 break;
6373 case PHONE_MAXRINGS:
6374 j->maxrings = arg;
6375 break;
6376 case PHONE_SET_TONE_ON_TIME:
6377 ixj_set_tone_on(arg, j);
6378 break;
6379 case PHONE_SET_TONE_OFF_TIME:
6380 ixj_set_tone_off(arg, j);
6381 break;
6382 case PHONE_GET_TONE_ON_TIME:
6383 if (ixj_get_tone_on(j)) {
6384 retval = -1;
6385 } else {
6386 retval = (j->ssr.high << 8) + j->ssr.low;
6387 }
6388 break;
6389 case PHONE_GET_TONE_OFF_TIME:
6390 if (ixj_get_tone_off(j)) {
6391 retval = -1;
6392 } else {
6393 retval = (j->ssr.high << 8) + j->ssr.low;
6394 }
6395 break;
6396 case PHONE_PLAY_TONE:
6397 if (!j->tone_state)
6398 retval = ixj_play_tone(j, arg);
6399 else
6400 retval = -1;
6401 break;
6402 case PHONE_GET_TONE_STATE:
6403 retval = j->tone_state;
6404 break;
6405 case PHONE_DTMF_READY:
6406 retval = j->ex.bits.dtmf_ready;
6407 break;
6408 case PHONE_GET_DTMF:
6409 if (ixj_hookstate(j)) {
6410 if (j->dtmf_rp != j->dtmf_wp) {
6411 retval = j->dtmfbuffer[j->dtmf_rp];
6412 j->dtmf_rp++;
6413 if (j->dtmf_rp == 79)
6414 j->dtmf_rp = 0;
6415 if (j->dtmf_rp == j->dtmf_wp) {
6416 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6417 }
6418 }
6419 }
6420 break;
6421 case PHONE_GET_DTMF_ASCII:
6422 if (ixj_hookstate(j)) {
6423 if (j->dtmf_rp != j->dtmf_wp) {
6424 switch (j->dtmfbuffer[j->dtmf_rp]) {
6425 case 10:
6426 retval = 42; /* '*'; */
6427
6428 break;
6429 case 11:
6430 retval = 48; /*'0'; */
6431
6432 break;
6433 case 12:
6434 retval = 35; /*'#'; */
6435
6436 break;
6437 case 28:
6438 retval = 65; /*'A'; */
6439
6440 break;
6441 case 29:
6442 retval = 66; /*'B'; */
6443
6444 break;
6445 case 30:
6446 retval = 67; /*'C'; */
6447
6448 break;
6449 case 31:
6450 retval = 68; /*'D'; */
6451
6452 break;
6453 default:
6454 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6455 break;
6456 }
6457 j->dtmf_rp++;
6458 if (j->dtmf_rp == 79)
6459 j->dtmf_rp = 0;
6460 if(j->dtmf_rp == j->dtmf_wp)
6461 {
6462 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6463 }
6464 }
6465 }
6466 break;
6467 case PHONE_DTMF_OOB:
6468 j->flags.dtmf_oob = arg;
6469 break;
6470 case PHONE_DIALTONE:
6471 ixj_dialtone(j);
6472 break;
6473 case PHONE_BUSY:
6474 ixj_busytone(j);
6475 break;
6476 case PHONE_RINGBACK:
6477 ixj_ringback(j);
6478 break;
6479 case PHONE_WINK:
6480 if(j->cardtype == QTI_PHONEJACK)
6481 retval = -1;
6482 else
6483 retval = ixj_wink(j);
6484 break;
6485 case PHONE_CPT_STOP:
6486 ixj_cpt_stop(j);
6487 break;
6488 case PHONE_QUERY_CODEC:
6489 {
6490 struct phone_codec_data pd;
6491 int val;
6492 int proto_size[] = {
6493 -1,
6494 12, 10, 16, 9, 8, 48, 5,
6495 40, 40, 80, 40, 40, 6
6496 };
6497 if(copy_from_user(&pd, argp, sizeof(pd))) {
6498 retval = -EFAULT;
6499 break;
6500 }
6501 if(pd.type<1 || pd.type>13) {
6502 retval = -EPROTONOSUPPORT;
6503 break;
6504 }
6505 if(pd.type<G729)
6506 val=proto_size[pd.type];
6507 else switch(j->baseframe.low)
6508 {
6509 case 0xA0:val=2*proto_size[pd.type];break;
6510 case 0x50:val=proto_size[pd.type];break;
6511 default:val=proto_size[pd.type]*3;break;
6512 }
6513 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6514 if(copy_to_user(argp, &pd, sizeof(pd)))
6515 retval = -EFAULT;
6516 break;
6517 }
6518 case IXJCTL_DSP_IDLE:
6519 idle(j);
6520 break;
6521 case IXJCTL_MIXER:
6522 if ((arg & 0xff) == 0xff)
6523 retval = ixj_get_mixer(arg, j);
6524 else
6525 ixj_mixer(arg, j);
6526 break;
6527 case IXJCTL_DAA_COEFF_SET:
6528 switch (arg) {
6529 case DAA_US:
6530 DAA_Coeff_US(j);
6531 retval = ixj_daa_write(j);
6532 break;
6533 case DAA_UK:
6534 DAA_Coeff_UK(j);
6535 retval = ixj_daa_write(j);
6536 break;
6537 case DAA_FRANCE:
6538 DAA_Coeff_France(j);
6539 retval = ixj_daa_write(j);
6540 break;
6541 case DAA_GERMANY:
6542 DAA_Coeff_Germany(j);
6543 retval = ixj_daa_write(j);
6544 break;
6545 case DAA_AUSTRALIA:
6546 DAA_Coeff_Australia(j);
6547 retval = ixj_daa_write(j);
6548 break;
6549 case DAA_JAPAN:
6550 DAA_Coeff_Japan(j);
6551 retval = ixj_daa_write(j);
6552 break;
6553 default:
6554 retval = 1;
6555 break;
6556 }
6557 break;
6558 case IXJCTL_DAA_AGAIN:
6559 ixj_daa_cr4(j, arg | 0x02);
6560 break;
6561 case IXJCTL_PSTN_LINETEST:
6562 retval = ixj_linetest(j);
6563 break;
6564 case IXJCTL_VMWI:
6565 ixj_write_vmwi(j, arg);
6566 break;
6567 case IXJCTL_CID:
6568 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6569 retval = -EFAULT;
6570 j->ex.bits.caller_id = 0;
6571 break;
6572 case IXJCTL_WINK_DURATION:
6573 j->winktime = arg;
6574 break;
6575 case IXJCTL_PORT:
6576 if (arg)
6577 retval = ixj_set_port(j, arg);
6578 else
6579 retval = j->port;
6580 break;
6581 case IXJCTL_POTS_PSTN:
6582 retval = ixj_set_pots(j, arg);
6583 break;
6584 case PHONE_CAPABILITIES:
6585 add_caps(j);
6586 retval = j->caps;
6587 break;
6588 case PHONE_CAPABILITIES_LIST:
6589 add_caps(j);
6590 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6591 retval = -EFAULT;
6592 break;
6593 case PHONE_CAPABILITIES_CHECK:
6594 {
6595 struct phone_capability cap;
6596 if (copy_from_user(&cap, argp, sizeof(cap)))
6597 retval = -EFAULT;
6598 else {
6599 add_caps(j);
6600 retval = capabilities_check(j, &cap);
6601 }
6602 }
6603 break;
6604 case PHONE_PSTN_SET_STATE:
6605 daa_set_mode(j, arg);
6606 break;
6607 case PHONE_PSTN_GET_STATE:
6608 retval = j->daa_mode;
6609 j->ex.bits.pstn_ring = 0;
6610 break;
6611 case IXJCTL_SET_FILTER:
6612 if (copy_from_user(&jf, argp, sizeof(jf)))
6613 retval = -EFAULT;
6614 retval = ixj_init_filter(j, &jf);
6615 break;
6616 case IXJCTL_SET_FILTER_RAW:
6617 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6618 retval = -EFAULT;
6619 else
6620 retval = ixj_init_filter_raw(j, &jfr);
6621 break;
6622 case IXJCTL_GET_FILTER_HIST:
6623 if(arg<0||arg>3)
6624 retval = -EINVAL;
6625 else
6626 retval = j->filter_hist[arg];
6627 break;
6628 case IXJCTL_INIT_TONE:
6629 if (copy_from_user(&ti, argp, sizeof(ti)))
6630 retval = -EFAULT;
6631 else
6632 retval = ixj_init_tone(j, &ti);
6633 break;
6634 case IXJCTL_TONE_CADENCE:
6635 retval = ixj_build_cadence(j, argp);
6636 break;
6637 case IXJCTL_FILTER_CADENCE:
6638 retval = ixj_build_filter_cadence(j, argp);
6639 break;
6640 case IXJCTL_SIGCTL:
6641 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6642 retval = -EFAULT;
6643 break;
6644 }
6645 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6646 if(j->sigdef.event < 33) {
6647 raise = 1;
6648 for(mant = 0; mant < j->sigdef.event; mant++){
6649 raise *= 2;
6650 }
6651 if(j->sigdef.signal)
6652 j->ex_sig.bytes |= raise;
6653 else
6654 j->ex_sig.bytes &= (raise^0xffff);
6655 }
6656 break;
6657 case IXJCTL_INTERCOM_STOP:
6658 if(arg < 0 || arg >= IXJMAX)
6659 return -EINVAL;
6660 j->intercom = -1;
6661 ixj_record_stop(j);
6662 ixj_play_stop(j);
6663 idle(j);
6664 get_ixj(arg)->intercom = -1;
6665 ixj_record_stop(get_ixj(arg));
6666 ixj_play_stop(get_ixj(arg));
6667 idle(get_ixj(arg));
6668 break;
6669 case IXJCTL_INTERCOM_START:
6670 if(arg < 0 || arg >= IXJMAX)
6671 return -EINVAL;
6672 j->intercom = arg;
6673 ixj_record_start(j);
6674 ixj_play_start(j);
6675 get_ixj(arg)->intercom = board;
6676 ixj_play_start(get_ixj(arg));
6677 ixj_record_start(get_ixj(arg));
6678 break;
6679 }
6680 if (ixjdebug & 0x0040)
6681 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6682 clear_bit(board, &j->busyflags);
6683 return retval;
6684 }
6685
6686 static int ixj_fasync(int fd, struct file *file_p, int mode)
6687 {
6688 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6689
6690 return fasync_helper(fd, file_p, mode, &j->async_queue);
6691 }
6692
6693 static struct file_operations ixj_fops =
6694 {
6695 .owner = THIS_MODULE,
6696 .read = ixj_enhanced_read,
6697 .write = ixj_enhanced_write,
6698 .poll = ixj_poll,
6699 .ioctl = ixj_ioctl,
6700 .release = ixj_release,
6701 .fasync = ixj_fasync
6702 };
6703
6704 static int ixj_linetest(IXJ *j)
6705 {
6706 unsigned long jifwait;
6707
6708 j->flags.pstncheck = 1; /* Testing */
6709 j->flags.pstn_present = 0; /* Assume the line is not there */
6710
6711 daa_int_read(j); /*Clear DAA Interrupt flags */
6712 /* */
6713 /* Hold all relays in the normally de-energized position. */
6714 /* */
6715
6716 j->pld_slicw.bits.rly1 = 0;
6717 j->pld_slicw.bits.rly2 = 0;
6718 j->pld_slicw.bits.rly3 = 0;
6719 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6720 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6721
6722 outb_p(j->pld_scrw.byte, j->XILINXbase);
6723 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6724 if (j->pld_slicr.bits.potspstn) {
6725 j->flags.pots_pstn = 1;
6726 j->flags.pots_correct = 0;
6727 LED_SetState(0x4, j);
6728 } else {
6729 j->flags.pots_pstn = 0;
6730 j->pld_slicw.bits.rly1 = 0;
6731 j->pld_slicw.bits.rly2 = 0;
6732 j->pld_slicw.bits.rly3 = 1;
6733 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6734 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6735
6736 outb_p(j->pld_scrw.byte, j->XILINXbase);
6737 daa_set_mode(j, SOP_PU_CONVERSATION);
6738 jifwait = jiffies + hertz;
6739 while (time_before(jiffies, jifwait)) {
6740 set_current_state(TASK_INTERRUPTIBLE);
6741 schedule_timeout(1);
6742 }
6743 daa_int_read(j);
6744 daa_set_mode(j, SOP_PU_RESET);
6745 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6746 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6747 LED_SetState(0x4, j);
6748 j->pld_slicw.bits.rly3 = 0;
6749 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6750 } else {
6751 j->flags.pots_correct = 1;
6752 LED_SetState(0x8, j);
6753 j->pld_slicw.bits.rly1 = 1;
6754 j->pld_slicw.bits.rly2 = 0;
6755 j->pld_slicw.bits.rly3 = 0;
6756 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6757 }
6758 }
6759 j->pld_slicw.bits.rly3 = 0;
6760 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6761 daa_set_mode(j, SOP_PU_CONVERSATION);
6762 jifwait = jiffies + hertz;
6763 while (time_before(jiffies, jifwait)) {
6764 set_current_state(TASK_INTERRUPTIBLE);
6765 schedule_timeout(1);
6766 }
6767 daa_int_read(j);
6768 daa_set_mode(j, SOP_PU_RESET);
6769 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6770 j->pstn_sleeptil = jiffies + (hertz / 4);
6771 j->flags.pstn_present = 1;
6772 } else {
6773 j->flags.pstn_present = 0;
6774 }
6775 if (j->flags.pstn_present) {
6776 if (j->flags.pots_correct) {
6777 LED_SetState(0xA, j);
6778 } else {
6779 LED_SetState(0x6, j);
6780 }
6781 } else {
6782 if (j->flags.pots_correct) {
6783 LED_SetState(0x9, j);
6784 } else {
6785 LED_SetState(0x5, j);
6786 }
6787 }
6788 j->flags.pstncheck = 0; /* Testing */
6789 return j->flags.pstn_present;
6790 }
6791
6792 static int ixj_selfprobe(IXJ *j)
6793 {
6794 unsigned short cmd;
6795 unsigned long jif;
6796 int cnt;
6797 BYTES bytes;
6798
6799 init_waitqueue_head(&j->poll_q);
6800 init_waitqueue_head(&j->read_q);
6801 init_waitqueue_head(&j->write_q);
6802
6803 while(atomic_read(&j->DSPWrite) > 0)
6804 atomic_dec(&j->DSPWrite);
6805 if (ixjdebug & 0x0002)
6806 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6807 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6808
6809 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6810 return -1;
6811 /* The read values of the SSR should be 0x00 for the IDLE command */
6812 if (j->ssr.low || j->ssr.high)
6813 return -1;
6814 if (ixjdebug & 0x0002)
6815 printk(KERN_INFO "Get Device ID Code\n");
6816 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6817 return -1;
6818 j->dsp.low = j->ssr.low;
6819 j->dsp.high = j->ssr.high;
6820 if (ixjdebug & 0x0002)
6821 printk(KERN_INFO "Get Device Version Code\n");
6822 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6823 return -1;
6824 j->ver.low = j->ssr.low;
6825 j->ver.high = j->ssr.high;
6826 if (!j->cardtype) {
6827 if (j->dsp.low == 0x21) {
6828 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6829 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6830 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6831 bytes.low = inb_p(j->XILINXbase + 0x02);
6832 if (bytes.low == bytes.high) /* Register is read only on */
6833 /* Internet PhoneJack Lite */
6834 {
6835 j->cardtype = QTI_PHONEJACK_LITE;
6836 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6837 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6838 return -1;
6839 }
6840 j->pld_slicw.pcib.e1 = 1;
6841 outb_p(j->pld_slicw.byte, j->XILINXbase);
6842 } else {
6843 j->cardtype = QTI_LINEJACK;
6844
6845 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6846 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6847 return -1;
6848 }
6849 }
6850 } else if (j->dsp.low == 0x22) {
6851 j->cardtype = QTI_PHONEJACK_PCI;
6852 request_region(j->XILINXbase, 4, "ixj control");
6853 j->pld_slicw.pcib.e1 = 1;
6854 outb_p(j->pld_slicw.byte, j->XILINXbase);
6855 } else
6856 j->cardtype = QTI_PHONEJACK;
6857 } else {
6858 switch (j->cardtype) {
6859 case QTI_PHONEJACK:
6860 if (!j->dsp.low != 0x20) {
6861 j->dsp.high = 0x80;
6862 j->dsp.low = 0x20;
6863 ixj_WriteDSPCommand(0x3800, j);
6864 j->ver.low = j->ssr.low;
6865 j->ver.high = j->ssr.high;
6866 }
6867 break;
6868 case QTI_LINEJACK:
6869 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6870 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6871 return -1;
6872 }
6873 break;
6874 case QTI_PHONEJACK_LITE:
6875 case QTI_PHONEJACK_PCI:
6876 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6877 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6878 return -1;
6879 }
6880 j->pld_slicw.pcib.e1 = 1;
6881 outb_p(j->pld_slicw.byte, j->XILINXbase);
6882 break;
6883 case QTI_PHONECARD:
6884 break;
6885 }
6886 }
6887 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6888 if (ixjdebug & 0x0002)
6889 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6890 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6891 return -1;
6892 if (ixjdebug & 0x0002)
6893 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6894 if (j->cardtype == QTI_PHONEJACK) {
6895 cmd = 0x9FF2;
6896 } else {
6897 cmd = 0x9FF5;
6898 }
6899 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6900 return -1;
6901 } else {
6902 if (set_base_frame(j, 30) != 30)
6903 return -1;
6904 if (ixjdebug & 0x0002)
6905 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6906 if (j->cardtype == QTI_PHONECARD) {
6907 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6908 return -1;
6909 }
6910 if (j->cardtype == QTI_LINEJACK) {
6911 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6912 return -1;
6913 if (ixjdebug & 0x0002)
6914 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6915 j->pld_clock.byte = 0;
6916 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6917 }
6918 }
6919
6920 if (j->dsp.low == 0x20) {
6921 if (ixjdebug & 0x0002)
6922 printk(KERN_INFO "Configure GPIO pins\n");
6923 j->gpio.bytes.high = 0x09;
6924 /* bytes.low = 0xEF; 0xF7 */
6925 j->gpio.bits.gpio1 = 1;
6926 j->gpio.bits.gpio2 = 1;
6927 j->gpio.bits.gpio3 = 0;
6928 j->gpio.bits.gpio4 = 1;
6929 j->gpio.bits.gpio5 = 1;
6930 j->gpio.bits.gpio6 = 1;
6931 j->gpio.bits.gpio7 = 1;
6932 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6933 if (ixjdebug & 0x0002)
6934 printk(KERN_INFO "Enable SLIC\n");
6935 j->gpio.bytes.high = 0x0B;
6936 j->gpio.bytes.low = 0x00;
6937 j->gpio.bits.gpio1 = 0;
6938 j->gpio.bits.gpio2 = 1;
6939 j->gpio.bits.gpio5 = 0;
6940 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6941 j->port = PORT_POTS;
6942 } else {
6943 if (j->cardtype == QTI_LINEJACK) {
6944 LED_SetState(0x1, j);
6945 jif = jiffies + (hertz / 10);
6946 while (time_before(jiffies, jif)) {
6947 set_current_state(TASK_INTERRUPTIBLE);
6948 schedule_timeout(1);
6949 }
6950 LED_SetState(0x2, j);
6951 jif = jiffies + (hertz / 10);
6952 while (time_before(jiffies, jif)) {
6953 set_current_state(TASK_INTERRUPTIBLE);
6954 schedule_timeout(1);
6955 }
6956 LED_SetState(0x4, j);
6957 jif = jiffies + (hertz / 10);
6958 while (time_before(jiffies, jif)) {
6959 set_current_state(TASK_INTERRUPTIBLE);
6960 schedule_timeout(1);
6961 }
6962 LED_SetState(0x8, j);
6963 jif = jiffies + (hertz / 10);
6964 while (time_before(jiffies, jif)) {
6965 set_current_state(TASK_INTERRUPTIBLE);
6966 schedule_timeout(1);
6967 }
6968 LED_SetState(0x0, j);
6969 daa_get_version(j);
6970 if (ixjdebug & 0x0002)
6971 printk("Loading DAA Coefficients\n");
6972 DAA_Coeff_US(j);
6973 if (!ixj_daa_write(j)) {
6974 printk("DAA write failed on board %d\n", j->board);
6975 return -1;
6976 }
6977 if(!ixj_daa_cid_reset(j)) {
6978 printk("DAA CID reset failed on board %d\n", j->board);
6979 return -1;
6980 }
6981 j->flags.pots_correct = 0;
6982 j->flags.pstn_present = 0;
6983 ixj_linetest(j);
6984 if (j->flags.pots_correct) {
6985 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6986
6987 outb_p(j->pld_scrw.byte, j->XILINXbase);
6988 j->pld_slicw.bits.rly1 = 1;
6989 j->pld_slicw.bits.spken = 1;
6990 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6991 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6992 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6993 j->port = PORT_POTS;
6994 }
6995 ixj_set_port(j, PORT_PSTN);
6996 ixj_set_pots(j, 1);
6997 if (ixjdebug & 0x0002)
6998 printk(KERN_INFO "Enable Mixer\n");
6999 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
7000 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
7001
7002 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
7003 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
7004
7005 ixj_mixer(0x0480, j); /*FM Left mute */
7006 ixj_mixer(0x0580, j); /*FM Right mute */
7007
7008 ixj_mixer(0x0680, j); /*CD Left mute */
7009 ixj_mixer(0x0780, j); /*CD Right mute */
7010
7011 ixj_mixer(0x0880, j); /*Line Left mute */
7012 ixj_mixer(0x0980, j); /*Line Right mute */
7013
7014 ixj_mixer(0x0A80, j); /*Aux left mute */
7015 ixj_mixer(0x0B80, j); /*Aux right mute */
7016
7017 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
7018 ixj_mixer(0x0D80, j); /*Mono2 mute */
7019
7020 ixj_mixer(0x0E80, j); /*Mic mute */
7021
7022 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
7023
7024 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
7025 ixj_mixer(0x110C, j);
7026
7027
7028 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
7029 ixj_mixer(0x1401, j);
7030
7031 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
7032 ixj_mixer(0x1501, j);
7033
7034 ixj_mixer(0x1700, j); /*Clock select */
7035
7036 ixj_mixer(0x1800, j); /*ADC input from mixer */
7037
7038 ixj_mixer(0x1901, j); /*Mic gain 30db */
7039
7040 if (ixjdebug & 0x0002)
7041 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7042 j->cadence_f[4].state = 0;
7043 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7044 j->cadence_f[4].off1 = 0;
7045 j->cadence_f[4].on2 = 0;
7046 j->cadence_f[4].off2 = 0;
7047 j->cadence_f[4].on3 = 0;
7048 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7049 j->pstn_last_rmr = jiffies;
7050
7051 } else {
7052 if (j->cardtype == QTI_PHONECARD) {
7053 ixj_WriteDSPCommand(0xCF07, j);
7054 ixj_WriteDSPCommand(0x00B0, j);
7055 ixj_set_port(j, PORT_SPEAKER);
7056 } else {
7057 ixj_set_port(j, PORT_POTS);
7058 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7059 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7060 }
7061 }
7062 }
7063
7064 j->intercom = -1;
7065 j->framesread = j->frameswritten = 0;
7066 j->read_wait = j->write_wait = 0;
7067 j->rxreadycheck = j->txreadycheck = 0;
7068
7069 /* initialise the DTMF prescale to a sensible value */
7070 if (j->cardtype == QTI_LINEJACK) {
7071 set_dtmf_prescale(j, 0x10);
7072 } else {
7073 set_dtmf_prescale(j, 0x40);
7074 }
7075 set_play_volume(j, 0x100);
7076 set_rec_volume(j, 0x100);
7077
7078 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7079 return -1;
7080 /* The read values of the SSR should be 0x00 for the IDLE command */
7081 if (j->ssr.low || j->ssr.high)
7082 return -1;
7083
7084 if (ixjdebug & 0x0002)
7085 printk(KERN_INFO "Enable Line Monitor\n");
7086
7087 if (ixjdebug & 0x0002)
7088 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7089
7090 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7091 return -1;
7092
7093 if (ixjdebug & 0x002)
7094 printk(KERN_INFO "Enable DTMF Detectors\n");
7095
7096 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7097 return -1;
7098
7099 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7100 return -1;
7101
7102 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7103
7104 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7105
7106 j->ex.bits.dtmf_ready = 0;
7107 j->dtmf_state = 0;
7108 j->dtmf_wp = j->dtmf_rp = 0;
7109 j->rec_mode = j->play_mode = -1;
7110 j->flags.ringing = 0;
7111 j->maxrings = MAXRINGS;
7112 j->ring_cadence = USA_RING_CADENCE;
7113 j->drybuffer = 0;
7114 j->winktime = 320;
7115 j->flags.dtmf_oob = 0;
7116 for (cnt = 0; cnt < 4; cnt++)
7117 j->cadence_f[cnt].enable = 0;
7118 /* must be a device on the specified address */
7119 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7120
7121 /* Set up the default signals for events */
7122 for (cnt = 0; cnt < 35; cnt++)
7123 j->ixj_signals[cnt] = SIGIO;
7124
7125 /* Set the excetion signal enable flags */
7126 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7127 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 =
7128 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;
7129 #ifdef IXJ_DYN_ALLOC
7130 j->fskdata = NULL;
7131 #endif
7132 j->fskdcnt = 0;
7133 j->cidcw_wait = 0;
7134
7135 /* Register with the Telephony for Linux subsystem */
7136 j->p.f_op = &ixj_fops;
7137 j->p.open = ixj_open;
7138 j->p.board = j->board;
7139 phone_register_device(&j->p, PHONE_UNIT_ANY);
7140
7141 ixj_init_timer(j);
7142 ixj_add_timer(j);
7143 return 0;
7144 }
7145
7146 /*
7147 * Exported service for pcmcia card handling
7148 */
7149
7150 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7151 {
7152 IXJ *j = ixj_alloc();
7153
7154 j->board = 0;
7155
7156 j->DSPbase = dsp;
7157 j->XILINXbase = xilinx;
7158 j->cardtype = QTI_PHONECARD;
7159 ixj_selfprobe(j);
7160 return j;
7161 }
7162
7163 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7164
7165 static int ixj_get_status_proc(char *buf)
7166 {
7167 int len;
7168 int cnt;
7169 IXJ *j;
7170 len = 0;
7171 len += sprintf(buf + len, "%s", ixj_c_rcsid);
7172 len += sprintf(buf + len, "\n%s", ixj_h_rcsid);
7173 len += sprintf(buf + len, "\n%s", ixjuser_h_rcsid);
7174 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7175 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7176 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7177 len += sprintf(buf + len, "\nUsing old telephony API");
7178 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7179
7180 for (cnt = 0; cnt < IXJMAX; cnt++) {
7181 j = get_ixj(cnt);
7182 if(j==NULL)
7183 continue;
7184 if (j->DSPbase) {
7185 len += sprintf(buf + len, "\nCard Num %d", cnt);
7186 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7187 if (j->cardtype != QTI_PHONEJACK)
7188 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7189 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7190 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7191 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7192 switch (j->cardtype) {
7193 case (QTI_PHONEJACK):
7194 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7195 break;
7196 case (QTI_LINEJACK):
7197 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7198 if (j->flags.g729_loaded)
7199 len += sprintf(buf + len, " w/G.729 A/B");
7200 len += sprintf(buf + len, " Country = %d", j->daa_country);
7201 break;
7202 case (QTI_PHONEJACK_LITE):
7203 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7204 if (j->flags.g729_loaded)
7205 len += sprintf(buf + len, " w/G.729 A/B");
7206 break;
7207 case (QTI_PHONEJACK_PCI):
7208 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7209 if (j->flags.g729_loaded)
7210 len += sprintf(buf + len, " w/G.729 A/B");
7211 break;
7212 case (QTI_PHONECARD):
7213 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7214 if (j->flags.g729_loaded)
7215 len += sprintf(buf + len, " w/G.729 A/B");
7216 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7217 if (!j->pccr1.bits.drf)
7218 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7219 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7220 break;
7221 default:
7222 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7223 break;
7224 }
7225 len += sprintf(buf + len, "\nReaders %d", j->readers);
7226 len += sprintf(buf + len, "\nWriters %d", j->writers);
7227 add_caps(j);
7228 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7229 if (j->dsp.low != 0x20)
7230 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7231 if (j->flags.cidsent)
7232 len += sprintf(buf + len, "\nCaller ID data sent");
7233 else
7234 len += sprintf(buf + len, "\nCaller ID data not sent");
7235
7236 len += sprintf(buf + len, "\nPlay CODEC ");
7237 switch (j->play_codec) {
7238 case G723_63:
7239 len += sprintf(buf + len, "G.723.1 6.3");
7240 break;
7241 case G723_53:
7242 len += sprintf(buf + len, "G.723.1 5.3");
7243 break;
7244 case TS85:
7245 len += sprintf(buf + len, "TrueSpeech 8.5");
7246 break;
7247 case TS48:
7248 len += sprintf(buf + len, "TrueSpeech 4.8");
7249 break;
7250 case TS41:
7251 len += sprintf(buf + len, "TrueSpeech 4.1");
7252 break;
7253 case G728:
7254 len += sprintf(buf + len, "G.728");
7255 break;
7256 case G729:
7257 len += sprintf(buf + len, "G.729");
7258 break;
7259 case G729B:
7260 len += sprintf(buf + len, "G.729B");
7261 break;
7262 case ULAW:
7263 len += sprintf(buf + len, "uLaw");
7264 break;
7265 case ALAW:
7266 len += sprintf(buf + len, "aLaw");
7267 break;
7268 case LINEAR16:
7269 len += sprintf(buf + len, "16 bit Linear");
7270 break;
7271 case LINEAR8:
7272 len += sprintf(buf + len, "8 bit Linear");
7273 break;
7274 case WSS:
7275 len += sprintf(buf + len, "Windows Sound System");
7276 break;
7277 default:
7278 len += sprintf(buf + len, "NO CODEC CHOSEN");
7279 break;
7280 }
7281 len += sprintf(buf + len, "\nRecord CODEC ");
7282 switch (j->rec_codec) {
7283 case G723_63:
7284 len += sprintf(buf + len, "G.723.1 6.3");
7285 break;
7286 case G723_53:
7287 len += sprintf(buf + len, "G.723.1 5.3");
7288 break;
7289 case TS85:
7290 len += sprintf(buf + len, "TrueSpeech 8.5");
7291 break;
7292 case TS48:
7293 len += sprintf(buf + len, "TrueSpeech 4.8");
7294 break;
7295 case TS41:
7296 len += sprintf(buf + len, "TrueSpeech 4.1");
7297 break;
7298 case G728:
7299 len += sprintf(buf + len, "G.728");
7300 break;
7301 case G729:
7302 len += sprintf(buf + len, "G.729");
7303 break;
7304 case G729B:
7305 len += sprintf(buf + len, "G.729B");
7306 break;
7307 case ULAW:
7308 len += sprintf(buf + len, "uLaw");
7309 break;
7310 case ALAW:
7311 len += sprintf(buf + len, "aLaw");
7312 break;
7313 case LINEAR16:
7314 len += sprintf(buf + len, "16 bit Linear");
7315 break;
7316 case LINEAR8:
7317 len += sprintf(buf + len, "8 bit Linear");
7318 break;
7319 case WSS:
7320 len += sprintf(buf + len, "Windows Sound System");
7321 break;
7322 default:
7323 len += sprintf(buf + len, "NO CODEC CHOSEN");
7324 break;
7325 }
7326 len += sprintf(buf + len, "\nAEC ");
7327 switch (j->aec_level) {
7328 case AEC_OFF:
7329 len += sprintf(buf + len, "Off");
7330 break;
7331 case AEC_LOW:
7332 len += sprintf(buf + len, "Low");
7333 break;
7334 case AEC_MED:
7335 len += sprintf(buf + len, "Med");
7336 break;
7337 case AEC_HIGH:
7338 len += sprintf(buf + len, "High");
7339 break;
7340 case AEC_AUTO:
7341 len += sprintf(buf + len, "Auto");
7342 break;
7343 case AEC_AGC:
7344 len += sprintf(buf + len, "AEC/AGC");
7345 break;
7346 default:
7347 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7348 break;
7349 }
7350
7351 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7352 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7353 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7354
7355 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7356
7357 if (j->cardtype == QTI_LINEJACK) {
7358 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7359 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7360 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7361 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7362 switch (j->daa_mode) {
7363 case SOP_PU_SLEEP:
7364 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7365 break;
7366 case SOP_PU_RINGING:
7367 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7368 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7369 break;
7370 case SOP_PU_CONVERSATION:
7371 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7372 break;
7373 case SOP_PU_PULSEDIALING:
7374 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7375 break;
7376 }
7377 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7378 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7379 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7380 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7381 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7382 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7383 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7384 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7385 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7386 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7387 }
7388 switch (j->port) {
7389 case PORT_POTS:
7390 len += sprintf(buf + len, "\nPort POTS");
7391 break;
7392 case PORT_PSTN:
7393 len += sprintf(buf + len, "\nPort PSTN");
7394 break;
7395 case PORT_SPEAKER:
7396 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7397 break;
7398 case PORT_HANDSET:
7399 len += sprintf(buf + len, "\nPort HANDSET");
7400 break;
7401 }
7402 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7403 len += sprintf(buf + len, "\nSLIC state ");
7404 switch (SLIC_GetState(j)) {
7405 case PLD_SLIC_STATE_OC:
7406 len += sprintf(buf + len, "OC");
7407 break;
7408 case PLD_SLIC_STATE_RINGING:
7409 len += sprintf(buf + len, "RINGING");
7410 break;
7411 case PLD_SLIC_STATE_ACTIVE:
7412 len += sprintf(buf + len, "ACTIVE");
7413 break;
7414 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7415 len += sprintf(buf + len, "OHT");
7416 break;
7417 case PLD_SLIC_STATE_TIPOPEN:
7418 len += sprintf(buf + len, "TIPOPEN");
7419 break;
7420 case PLD_SLIC_STATE_STANDBY:
7421 len += sprintf(buf + len, "STANDBY");
7422 break;
7423 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7424 len += sprintf(buf + len, "APR");
7425 break;
7426 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7427 len += sprintf(buf + len, "OHTPR");
7428 break;
7429 default:
7430 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7431 break;
7432 }
7433 }
7434 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7435 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7436 #ifdef PERFMON_STATS
7437 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7438 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7439 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7440 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7441 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7442 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7443 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7444 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7445 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7446 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7447 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7448 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7449 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7450 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7451
7452 #endif
7453 len += sprintf(buf + len, "\n");
7454 }
7455 }
7456 return len;
7457 }
7458
7459 static int ixj_read_proc(char *page, char **start, off_t off,
7460 int count, int *eof, void *data)
7461 {
7462 int len = ixj_get_status_proc(page);
7463 if (len <= off+count) *eof = 1;
7464 *start = page + off;
7465 len -= off;
7466 if (len>count) len = count;
7467 if (len<0) len = 0;
7468 return len;
7469 }
7470
7471
7472 static void cleanup(void)
7473 {
7474 int cnt;
7475 IXJ *j;
7476
7477 for (cnt = 0; cnt < IXJMAX; cnt++) {
7478 j = get_ixj(cnt);
7479 if(j != NULL && j->DSPbase) {
7480 if (ixjdebug & 0x0002)
7481 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7482 del_timer(&j->timer);
7483 if (j->cardtype == QTI_LINEJACK) {
7484 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7485
7486 outb_p(j->pld_scrw.byte, j->XILINXbase);
7487 j->pld_slicw.bits.rly1 = 0;
7488 j->pld_slicw.bits.rly2 = 0;
7489 j->pld_slicw.bits.rly3 = 0;
7490 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7491 LED_SetState(0x0, j);
7492 if (ixjdebug & 0x0002)
7493 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7494 release_region(j->XILINXbase, 8);
7495 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7496 if (ixjdebug & 0x0002)
7497 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7498 release_region(j->XILINXbase, 4);
7499 }
7500 if (j->read_buffer)
7501 kfree(j->read_buffer);
7502 if (j->write_buffer)
7503 kfree(j->write_buffer);
7504 if (j->dev)
7505 pnp_device_detach(j->dev);
7506 if (ixjdebug & 0x0002)
7507 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7508 phone_unregister_device(&j->p);
7509 if (ixjdebug & 0x0002)
7510 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7511 release_region(j->DSPbase, 16);
7512 #ifdef IXJ_DYN_ALLOC
7513 if (ixjdebug & 0x0002)
7514 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7515 kfree(j);
7516 ixj[cnt] = NULL;
7517 #endif
7518 }
7519 }
7520 if (ixjdebug & 0x0002)
7521 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7522 remove_proc_entry ("ixj", NULL);
7523 }
7524
7525 /* Typedefs */
7526 typedef struct {
7527 BYTE length;
7528 DWORD bits;
7529 } DATABLOCK;
7530
7531 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7532 {
7533 lastLCC = lastLCC & 0xfb;
7534 lastLCC = lastLCC | (byData ? 4 : 0);
7535 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7536
7537 mdelay(1);
7538 lastLCC = lastLCC | 0x01;
7539 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7540
7541 byData = byData << 1;
7542 lastLCC = lastLCC & 0xfe;
7543 mdelay(1);
7544 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7545
7546 }
7547
7548 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7549 {
7550 mdelay(1);
7551 lastLCC = lastLCC | 0x01;
7552 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7553
7554 lastLCC = lastLCC & 0xfe;
7555 mdelay(1);
7556 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7557
7558 return ((inb(wEEPROMAddress) >> 3) & 1);
7559 }
7560
7561 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7562 {
7563 BYTE lastLCC;
7564 WORD wEEPROMAddress = wAddress + 3;
7565 DWORD i;
7566 BYTE byResult;
7567 *pwResult = 0;
7568 lastLCC = inb(wEEPROMAddress);
7569 lastLCC = lastLCC | 0x02;
7570 lastLCC = lastLCC & 0xfe;
7571 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7572
7573 mdelay(1); /* delay */
7574
7575 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7576 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7577 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7578 for (i = 0; i < 8; i++) {
7579 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7580 wLoc <<= 1;
7581 }
7582
7583 for (i = 0; i < 16; i++) {
7584 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7585 *pwResult = (*pwResult << 1) | byResult;
7586 }
7587
7588 mdelay(1); /* another delay */
7589
7590 lastLCC = lastLCC & 0xfd;
7591 outb(lastLCC, wEEPROMAddress); /* negate CS */
7592
7593 return 0;
7594 }
7595
7596 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7597 {
7598 WORD wLo, wHi;
7599 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7600 return 0;
7601 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7602 return 0;
7603 return (((DWORD) wHi << 16) | wLo);
7604 }
7605
7606 static int dspio[IXJMAX + 1] =
7607 {
7608 0,
7609 };
7610 static int xio[IXJMAX + 1] =
7611 {
7612 0,
7613 };
7614
7615 module_param_array(dspio, int, NULL, 0);
7616 module_param_array(xio, int, NULL, 0);
7617 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7618 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7619 MODULE_LICENSE("GPL");
7620
7621 static void __exit ixj_exit(void)
7622 {
7623 cleanup();
7624 }
7625
7626 static IXJ *new_ixj(unsigned long port)
7627 {
7628 IXJ *res;
7629 if (!request_region(port, 16, "ixj DSP")) {
7630 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7631 return NULL;
7632 }
7633 res = ixj_alloc();
7634 if (!res) {
7635 release_region(port, 16);
7636 printk(KERN_INFO "ixj: out of memory\n");
7637 return NULL;
7638 }
7639 res->DSPbase = port;
7640 return res;
7641 }
7642
7643 static int __init ixj_probe_isapnp(int *cnt)
7644 {
7645 int probe = 0;
7646 int func = 0x110;
7647 struct pnp_dev *dev = NULL, *old_dev = NULL;
7648
7649 while (1) {
7650 do {
7651 IXJ *j;
7652 int result;
7653
7654 old_dev = dev;
7655 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7656 ISAPNP_FUNCTION(func), old_dev);
7657 if (!dev || !dev->card)
7658 break;
7659 result = pnp_device_attach(dev);
7660 if (result < 0) {
7661 printk("pnp attach failed %d \n", result);
7662 break;
7663 }
7664 if (pnp_activate_dev(dev) < 0) {
7665 printk("pnp activate failed (out of resources?)\n");
7666 pnp_device_detach(dev);
7667 return -ENOMEM;
7668 }
7669
7670 if (!pnp_port_valid(dev, 0)) {
7671 pnp_device_detach(dev);
7672 return -ENODEV;
7673 }
7674
7675 j = new_ixj(pnp_port_start(dev, 0));
7676 if (!j)
7677 break;
7678
7679 if (func != 0x110)
7680 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7681
7682 switch (func) {
7683 case (0x110):
7684 j->cardtype = QTI_PHONEJACK;
7685 break;
7686 case (0x310):
7687 j->cardtype = QTI_LINEJACK;
7688 break;
7689 case (0x410):
7690 j->cardtype = QTI_PHONEJACK_LITE;
7691 break;
7692 }
7693 j->board = *cnt;
7694 probe = ixj_selfprobe(j);
7695 if(!probe) {
7696 j->serial = dev->card->serial;
7697 j->dev = dev;
7698 switch (func) {
7699 case 0x110:
7700 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7701 break;
7702 case 0x310:
7703 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7704 break;
7705 case 0x410:
7706 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7707 break;
7708 }
7709 }
7710 ++*cnt;
7711 } while (dev);
7712 if (func == 0x410)
7713 break;
7714 if (func == 0x310)
7715 func = 0x410;
7716 if (func == 0x110)
7717 func = 0x310;
7718 dev = NULL;
7719 }
7720 return probe;
7721 }
7722
7723 static int __init ixj_probe_isa(int *cnt)
7724 {
7725 int i, probe;
7726
7727 /* Use passed parameters for older kernels without PnP */
7728 for (i = 0; i < IXJMAX; i++) {
7729 if (dspio[i]) {
7730 IXJ *j = new_ixj(dspio[i]);
7731
7732 if (!j)
7733 break;
7734
7735 j->XILINXbase = xio[i];
7736 j->cardtype = 0;
7737
7738 j->board = *cnt;
7739 probe = ixj_selfprobe(j);
7740 j->dev = NULL;
7741 ++*cnt;
7742 }
7743 }
7744 return 0;
7745 }
7746
7747 static int __init ixj_probe_pci(int *cnt)
7748 {
7749 struct pci_dev *pci = NULL;
7750 int i, probe = 0;
7751 IXJ *j = NULL;
7752
7753 for (i = 0; i < IXJMAX - *cnt; i++) {
7754 pci = pci_find_device(0x15E2, 0x0500, pci);
7755 if (!pci)
7756 break;
7757
7758 if (pci_enable_device(pci))
7759 break;
7760 j = new_ixj(pci_resource_start(pci, 0));
7761 if (!j)
7762 break;
7763
7764 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7765 j->XILINXbase = j->DSPbase + 0x10;
7766 j->cardtype = QTI_PHONEJACK_PCI;
7767 j->board = *cnt;
7768 probe = ixj_selfprobe(j);
7769 if (!probe)
7770 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7771 ++*cnt;
7772 }
7773 return probe;
7774 }
7775
7776 static int __init ixj_init(void)
7777 {
7778 int cnt = 0;
7779 int probe = 0;
7780
7781 cnt = 0;
7782
7783 /* These might be no-ops, see above. */
7784 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7785 return probe;
7786 }
7787 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7788 return probe;
7789 }
7790 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7791 return probe;
7792 }
7793 printk("%s\n", ixj_c_rcsid);
7794 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7795 return probe;
7796 }
7797
7798 module_init(ixj_init);
7799 module_exit(ixj_exit);
7800
7801 static void DAA_Coeff_US(IXJ *j)
7802 {
7803 int i;
7804
7805 j->daa_country = DAA_US;
7806 /*----------------------------------------------- */
7807 /* CAO */
7808 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7809 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7810 }
7811
7812 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7813 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7814 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7815 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7816 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7817 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7818 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7819 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7820 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7821 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7822 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7823 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7824 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7825 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7826 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7827 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7828 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7829 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7830 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7831 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7832 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7833 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7834 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7835 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7836 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7837 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7838 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7839 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7840 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7841 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7842 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7843 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7844 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7845 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7846 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7847 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7848 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7849 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7850 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7851 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7852 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7853 /* Bytes for AR-filter (09): 52,D3,11,42 */
7854 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7855 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7856 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7857 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7858 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7859 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7860 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7861 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7862 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7863 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7864 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7865 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7866 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7867 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7868 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7869 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7870 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7871 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7872 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7873 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7874 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7875 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7876 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7877 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7878 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7879 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7880 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7881 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7882 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7883 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7884 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7885 /* ; (10K, 0.68uF) */
7886 /* */
7887 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7888 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7889 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7890 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7891 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7892 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7893 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7894 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7895 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7896 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7897 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7898 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7899 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7900 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7901 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7902 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7903 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7904 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7905
7906 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7907 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7908 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7909 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7910 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7911
7912 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7913 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7914 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7915 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7916 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7917 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7918 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7919 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7920 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7921 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7922 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7923 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7924 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7925 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7926 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7927 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7928 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7929 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7930 /* */
7931 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7932 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7933 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7934 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7935 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7936
7937 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7938 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7939 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7940 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7941 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7942 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7943 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7944 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7945 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7946 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7947 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7948 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7949 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7950 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7951 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7952 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7953 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7954 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7955 /* */
7956 /* ;CR Registers */
7957 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7958 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7959 /* Config. Reg. 1 (dialing) (cr1):05 */
7960 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7961 /* Config. Reg. 2 (caller ID) (cr2):04 */
7962 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7963 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7964 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7965 /* Config. Reg. 4 (analog gain) (cr4):02 */
7966 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7967 /* Config. Reg. 5 (Version) (cr5):02 */
7968 /* Config. Reg. 6 (Reserved) (cr6):00 */
7969 /* Config. Reg. 7 (Reserved) (cr7):00 */
7970 /* */
7971 /* ;xr Registers */
7972 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7973
7974 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7975 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7976
7977 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7978 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7979 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7980 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7981 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7982 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7983
7984 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7985 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7986 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7987 /* Ext. Reg. 6 (Power State) (xr6):00 */
7988 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7989 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7990 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7991 /* */
7992 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7993 /* 12,33,5A,C3 ; 770 Hz */
7994 /* 13,3C,5B,32 ; 852 Hz */
7995 /* 1D,1B,5C,CC ; 941 Hz */
7996
7997 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7998 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7999 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8000 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8001 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8002 /* EC,1D,52,22 ; 1336 Hz */
8003 /* AA,AC,51,D2 ; 1477 Hz */
8004 /* 9B,3B,51,25 ; 1633 Hz */
8005 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8006 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8007 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8008 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8009 }
8010
8011 static void DAA_Coeff_UK(IXJ *j)
8012 {
8013 int i;
8014
8015 j->daa_country = DAA_UK;
8016 /*----------------------------------------------- */
8017 /* CAO */
8018 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8019 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8020 }
8021
8022 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8023 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8024 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8025 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8026 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8027 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8028 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8029 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8030 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8031 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8032 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8033 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8034 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8035 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8036 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8037 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8038 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8039 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8040 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
8041 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8042 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8043 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8044 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8045 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8046 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8047 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8048 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8049 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8050 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8051 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8052 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8053 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8054 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8055 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8056 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8057 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8058 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8059 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8060 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8061 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8062 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8063 /* Bytes for AR-filter (09): E2,27,10,D6 */
8064 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8065 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8066 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8067 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8068 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8069 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8070 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8071 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8072 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8073 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8074 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8075 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8076 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8077 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8078 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8079 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8080 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8081 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8082 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8083 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8084 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8085 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8086 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8087 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8088 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8089 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8090 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8091 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8092 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8093 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8094 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8095 /* ; idle */
8096 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8097 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8098 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8099 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8100 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8101 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8102 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8103 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8104 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8105 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8106 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8107 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8108 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8109 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8110 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8111 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8112 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8113 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8114 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8115 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8116 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8117 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8118 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8119 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8120 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8121 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8122 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8123 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8124 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8125 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8126 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8127 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8128 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8129 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8130 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8131 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8132 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8133 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8134 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8135 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8136 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8137 /* ;CR Registers */
8138 /* Config. Reg. 0 (filters) (cr0):FF */
8139 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8140 /* Config. Reg. 1 (dialing) (cr1):05 */
8141 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8142 /* Config. Reg. 2 (caller ID) (cr2):04 */
8143 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8144 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8145 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8146 /* Config. Reg. 4 (analog gain) (cr4):02 */
8147 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8148 /* Config. Reg. 5 (Version) (cr5):02 */
8149 /* Config. Reg. 6 (Reserved) (cr6):00 */
8150 /* Config. Reg. 7 (Reserved) (cr7):00 */
8151 /* ;xr Registers */
8152 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8153
8154 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8155 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8156
8157 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8158 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8159
8160 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8161 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8162 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8163 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8164 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8165 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8166 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8167 /* Ext. Reg. 6 (Power State) (xr6):00 */
8168 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8169 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8170 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8171 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8172 /* 12,33,5A,C3 ; 770 Hz */
8173 /* 13,3C,5B,32 ; 852 Hz */
8174 /* 1D,1B,5C,CC ; 941 Hz */
8175
8176 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8177 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8178 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8179 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8180 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8181 /* EC,1D,52,22 ; 1336 Hz */
8182 /* AA,AC,51,D2 ; 1477 Hz */
8183 /* 9B,3B,51,25 ; 1633 Hz */
8184 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8185 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8186 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8187 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8188 }
8189
8190
8191 static void DAA_Coeff_France(IXJ *j)
8192 {
8193 int i;
8194
8195 j->daa_country = DAA_FRANCE;
8196 /*----------------------------------------------- */
8197 /* CAO */
8198 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8199 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8200 }
8201
8202 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8203 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8204 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8205 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8206 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8207 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8208 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8209 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8210 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8211 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8212 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8213 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8214 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8215 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8216 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8217 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8218 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8219 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8220 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8221 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8222 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8223 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8224 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8225 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8226 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8227 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8228 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8229 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8230 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8231 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8232 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8233 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8234 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8235 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8236 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8237 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8238 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8239 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8240 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8241 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8242 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8243 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8244 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8245 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8246 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8247 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8248 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8249 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8250 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8251 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8252 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8253 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8254 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8255 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8256 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8257 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8258 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8259 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8260 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8261 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8262 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8263 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8264 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8265 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8266 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8267 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8268 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8269 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8270 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8271 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8272 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8273 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8274 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8275 /* ; idle */
8276 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8277 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8278 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8279 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8280 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8281 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8282 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8283 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8284 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8285 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8286 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8287 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8288 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8289 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8290 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8291 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8292 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8293 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8294 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8295 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8296 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8297 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8298 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8299 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8300 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8301 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8302 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8303 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8304 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8305 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8306 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8307 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8308 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8309 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8310 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8311 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8312 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8313 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8314 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8315 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8316 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8317 /* ;CR Registers */
8318 /* Config. Reg. 0 (filters) (cr0):FF */
8319 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8320 /* Config. Reg. 1 (dialing) (cr1):05 */
8321 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8322 /* Config. Reg. 2 (caller ID) (cr2):04 */
8323 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8324 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8325 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8326 /* Config. Reg. 4 (analog gain) (cr4):02 */
8327 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8328 /* Config. Reg. 5 (Version) (cr5):02 */
8329 /* Config. Reg. 6 (Reserved) (cr6):00 */
8330 /* Config. Reg. 7 (Reserved) (cr7):00 */
8331 /* ;xr Registers */
8332 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8333
8334 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8335 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8336
8337 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8338 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8339
8340 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8341 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8342 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8343 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8344 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8345 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8346 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8347 /* Ext. Reg. 6 (Power State) (xr6):00 */
8348 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8349 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8350 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8351 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8352 /* 12,33,5A,C3 ; 770 Hz */
8353 /* 13,3C,5B,32 ; 852 Hz */
8354 /* 1D,1B,5C,CC ; 941 Hz */
8355
8356 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8357 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8358 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8359 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8360 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8361 /* EC,1D,52,22 ; 1336 Hz */
8362 /* AA,AC,51,D2 ; 1477 Hz */
8363 /* 9B,3B,51,25 ; 1633 Hz */
8364 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8365 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8366 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8367 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8368 }
8369
8370
8371 static void DAA_Coeff_Germany(IXJ *j)
8372 {
8373 int i;
8374
8375 j->daa_country = DAA_GERMANY;
8376 /*----------------------------------------------- */
8377 /* CAO */
8378 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8379 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8380 }
8381
8382 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8383 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8384 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8385 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8386 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8387 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8388 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8389 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8390 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8391 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8392 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8393 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8394 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8395 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8396 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8397 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8398 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8399 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8400 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8401 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8402 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8403 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8404 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8405 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8406 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8407 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8408 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8409 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8410 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8411 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8412 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8413 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8414 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8415 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8416 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8417 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8418 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8419 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8420 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8421 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8422 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8423 /* Bytes for AR-filter (09): 72,42,13,4B */
8424 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8425 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8426 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8427 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8428 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8429 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8430 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8431 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8432 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8433 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8434 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8435 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8436 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8437 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8438 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8439 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8440 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8441 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8442 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8443 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8444 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8445 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8446 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8447 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8448 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8449 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8450 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8451 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8452 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8453 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8454 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8455 /* ; (10K, 0.68uF) */
8456 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8457 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8458 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8459 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8460 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8461 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8462 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8463 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8464 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8465 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8466 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8467 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8468 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8469 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8470 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8471 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8472 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8473 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8474 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8475 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8476 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8477 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8478 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8479 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8480 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8481 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8482 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8483 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8484 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8485 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8486 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8487 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8488 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8489 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8490 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8491 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8492 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8493 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8494 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8495 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8496 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8497 /* ;CR Registers */
8498 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8499 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8500 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8501 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8502 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8503 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8504 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8505 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8506 /* Config. Reg. 4 (analog gain) (cr4):02 */
8507 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8508 /* Config. Reg. 5 (Version) (cr5):02 */
8509 /* Config. Reg. 6 (Reserved) (cr6):00 */
8510 /* Config. Reg. 7 (Reserved) (cr7):00 */
8511 /* ;xr Registers */
8512 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8513
8514 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8515 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8516
8517 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8518 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8519
8520 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8521 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8522 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8523 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8524 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8525 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8526 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8527 /* Ext. Reg. 6 (Power State) (xr6):00 */
8528 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8529 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8530 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8531 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8532 /* 12,33,5A,C3 ; 770 Hz */
8533 /* 13,3C,5B,32 ; 852 Hz */
8534 /* 1D,1B,5C,CC ; 941 Hz */
8535
8536 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8537 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8538 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8539 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8540 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8541 /* EC,1D,52,22 ; 1336 Hz */
8542 /* AA,AC,51,D2 ; 1477 Hz */
8543 /* 9B,3B,51,25 ; 1633 Hz */
8544 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8545 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8546 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8547 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8548 }
8549
8550
8551 static void DAA_Coeff_Australia(IXJ *j)
8552 {
8553 int i;
8554
8555 j->daa_country = DAA_AUSTRALIA;
8556 /*----------------------------------------------- */
8557 /* CAO */
8558 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8559 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8560 }
8561
8562 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8563 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8564 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8565 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8566 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8567 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8568 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8569 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8570 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8571 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8572 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8573 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8574 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8575 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8576 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8577 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8578 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8579 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8580 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8581 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8582 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8583 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8584 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8585 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8586 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8587 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8588 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8589 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8590 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8591 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8592 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8593 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8594 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8595 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8596 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8597 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8598 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8599 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8600 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8601 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8602 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8603 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8604 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8605 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8606 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8607 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8608 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8609 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8610 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8611 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8612 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8613 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8614 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8615 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8616 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8617 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8618 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8619 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8620 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8621 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8622 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8623 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8624 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8625 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8626 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8627 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8628 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8629 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8630 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8631 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8632 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8633 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8634 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8635 /* ; idle */
8636 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8637 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8638 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8639 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8640 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8641 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8642 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8643 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8644 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8645 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8646 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8647 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8648 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8649 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8650 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8651 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8652 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8653 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8654 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8655 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8656 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8657 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8658 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8659 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8660 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8661 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8662 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8663 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8664 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8665 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8666 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8667 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8668 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8669 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8670 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8671 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8672 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8673 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8674 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8675 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8676 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8677 /* ;CR Registers */
8678 /* Config. Reg. 0 (filters) (cr0):FF */
8679 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8680 /* Config. Reg. 1 (dialing) (cr1):05 */
8681 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8682 /* Config. Reg. 2 (caller ID) (cr2):04 */
8683 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8684 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8685 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8686 /* Config. Reg. 4 (analog gain) (cr4):02 */
8687 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8688 /* Config. Reg. 5 (Version) (cr5):02 */
8689 /* Config. Reg. 6 (Reserved) (cr6):00 */
8690 /* Config. Reg. 7 (Reserved) (cr7):00 */
8691 /* ;xr Registers */
8692 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8693
8694 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8695 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8696
8697 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8698 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8699
8700 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8701 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8702 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8703 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8704 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8705 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8706 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8707 /* Ext. Reg. 6 (Power State) (xr6):00 */
8708 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8709 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8710 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8711
8712 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8713 /* 12,33,5A,C3 ; 770 Hz */
8714 /* 13,3C,5B,32 ; 852 Hz */
8715 /* 1D,1B,5C,CC ; 941 Hz */
8716 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8717 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8718 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8719 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8720
8721 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8722 /* EC,1D,52,22 ; 1336 Hz */
8723 /* AA,AC,51,D2 ; 1477 Hz */
8724 /* 9B,3B,51,25 ; 1633 Hz */
8725 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8726 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8727 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8728 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8729 }
8730
8731 static void DAA_Coeff_Japan(IXJ *j)
8732 {
8733 int i;
8734
8735 j->daa_country = DAA_JAPAN;
8736 /*----------------------------------------------- */
8737 /* CAO */
8738 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8739 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8740 }
8741
8742 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8743 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8744 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8745 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8746 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8747 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8748 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8749 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8750 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8751 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8752 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8753 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8754 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8755 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8756 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8757 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8758 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8759 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8760 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8761 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8762 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8763 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8764 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8765 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8766 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8767 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8768 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8769 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8770 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8771 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8772 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8773 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8774 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8775 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8776 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8777 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8778 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8779 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8780 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8781 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8782 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8783 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8784 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8785 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8786 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8787 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8788 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8789 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8790 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8791 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8792 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8793 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8794 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8795 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8796 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8797 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8798 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8799 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8800 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8801 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8802 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8803 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8804 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8805 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8806 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8807 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8815 /* ; idle */
8816 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8817 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8818 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8819 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8820 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8821 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8822 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8823 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8824 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8825 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8826 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8827 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8828 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8829 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8830 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8831 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8832 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8833 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8834 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8835 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8836 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8837 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8838 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8839 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8840 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8841 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8842 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8843 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8844 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8845 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8846 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8847 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8848 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8849 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8850 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8851 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8852 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8853 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8854 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8855 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8856 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8857 /* ;CR Registers */
8858 /* Config. Reg. 0 (filters) (cr0):FF */
8859 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8860 /* Config. Reg. 1 (dialing) (cr1):05 */
8861 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8862 /* Config. Reg. 2 (caller ID) (cr2):04 */
8863 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8864 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8865 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8866 /* Config. Reg. 4 (analog gain) (cr4):02 */
8867 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8868 /* Config. Reg. 5 (Version) (cr5):02 */
8869 /* Config. Reg. 6 (Reserved) (cr6):00 */
8870 /* Config. Reg. 7 (Reserved) (cr7):00 */
8871 /* ;xr Registers */
8872 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8873
8874 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8875 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8876
8877 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8878 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8879
8880 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8881 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8882 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8883 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8884 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8885 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8886 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8887 /* Ext. Reg. 6 (Power State) (xr6):00 */
8888 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8889 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8890 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8891 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8892 /* 12,33,5A,C3 ; 770 Hz */
8893 /* 13,3C,5B,32 ; 852 Hz */
8894 /* 1D,1B,5C,CC ; 941 Hz */
8895
8896 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8897 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8898 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8899 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8900 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8901 /* EC,1D,52,22 ; 1336 Hz */
8902 /* AA,AC,51,D2 ; 1477 Hz */
8903 /* 9B,3B,51,25 ; 1633 Hz */
8904 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8905 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8906 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8907 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8908 }
8909
8910 static s16 tone_table[][19] =
8911 {
8912 { /* f20_50[] 11 */
8913 32538, /* A1 = 1.985962 */
8914 -32325, /* A2 = -0.986511 */
8915 -343, /* B2 = -0.010493 */
8916 0, /* B1 = 0 */
8917 343, /* B0 = 0.010493 */
8918 32619, /* A1 = 1.990906 */
8919 -32520, /* A2 = -0.992462 */
8920 19179, /* B2 = 0.585327 */
8921 -19178, /* B1 = -1.170593 */
8922 19179, /* B0 = 0.585327 */
8923 32723, /* A1 = 1.997314 */
8924 -32686, /* A2 = -0.997528 */
8925 9973, /* B2 = 0.304352 */
8926 -9955, /* B1 = -0.607605 */
8927 9973, /* B0 = 0.304352 */
8928 7, /* Internal filter scaling */
8929 159, /* Minimum in-band energy threshold */
8930 21, /* 21/32 in-band to broad-band ratio */
8931 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8932 },
8933 { /* f133_200[] 12 */
8934 32072, /* A1 = 1.95752 */
8935 -31896, /* A2 = -0.973419 */
8936 -435, /* B2 = -0.013294 */
8937 0, /* B1 = 0 */
8938 435, /* B0 = 0.013294 */
8939 32188, /* A1 = 1.9646 */
8940 -32400, /* A2 = -0.98877 */
8941 15139, /* B2 = 0.462036 */
8942 -14882, /* B1 = -0.908356 */
8943 15139, /* B0 = 0.462036 */
8944 32473, /* A1 = 1.981995 */
8945 -32524, /* A2 = -0.992584 */
8946 23200, /* B2 = 0.708008 */
8947 -23113, /* B1 = -1.410706 */
8948 23200, /* B0 = 0.708008 */
8949 7, /* Internal filter scaling */
8950 159, /* Minimum in-band energy threshold */
8951 21, /* 21/32 in-band to broad-band ratio */
8952 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8953 },
8954 { /* f300 13 */
8955 31769, /* A1 = -1.939026 */
8956 -32584, /* A2 = 0.994385 */
8957 -475, /* B2 = -0.014522 */
8958 0, /* B1 = 0.000000 */
8959 475, /* B0 = 0.014522 */
8960 31789, /* A1 = -1.940247 */
8961 -32679, /* A2 = 0.997284 */
8962 17280, /* B2 = 0.527344 */
8963 -16865, /* B1 = -1.029358 */
8964 17280, /* B0 = 0.527344 */
8965 31841, /* A1 = -1.943481 */
8966 -32681, /* A2 = 0.997345 */
8967 543, /* B2 = 0.016579 */
8968 -525, /* B1 = -0.032097 */
8969 543, /* B0 = 0.016579 */
8970 5, /* Internal filter scaling */
8971 159, /* Minimum in-band energy threshold */
8972 21, /* 21/32 in-band to broad-band ratio */
8973 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8974 },
8975 { /* f300_420[] 14 */
8976 30750, /* A1 = 1.876892 */
8977 -31212, /* A2 = -0.952515 */
8978 -804, /* B2 = -0.024541 */
8979 0, /* B1 = 0 */
8980 804, /* B0 = 0.024541 */
8981 30686, /* A1 = 1.872925 */
8982 -32145, /* A2 = -0.980988 */
8983 14747, /* B2 = 0.450043 */
8984 -13703, /* B1 = -0.836395 */
8985 14747, /* B0 = 0.450043 */
8986 31651, /* A1 = 1.931824 */
8987 -32321, /* A2 = -0.986389 */
8988 24425, /* B2 = 0.745422 */
8989 -23914, /* B1 = -1.459595 */
8990 24427, /* B0 = 0.745483 */
8991 7, /* Internal filter scaling */
8992 159, /* Minimum in-band energy threshold */
8993 21, /* 21/32 in-band to broad-band ratio */
8994 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8995 },
8996 { /* f330 15 */
8997 31613, /* A1 = -1.929565 */
8998 -32646, /* A2 = 0.996277 */
8999 -185, /* B2 = -0.005657 */
9000 0, /* B1 = 0.000000 */
9001 185, /* B0 = 0.005657 */
9002 31620, /* A1 = -1.929932 */
9003 -32713, /* A2 = 0.998352 */
9004 19253, /* B2 = 0.587585 */
9005 -18566, /* B1 = -1.133179 */
9006 19253, /* B0 = 0.587585 */
9007 31674, /* A1 = -1.933228 */
9008 -32715, /* A2 = 0.998413 */
9009 2575, /* B2 = 0.078590 */
9010 -2495, /* B1 = -0.152283 */
9011 2575, /* B0 = 0.078590 */
9012 5, /* Internal filter scaling */
9013 159, /* Minimum in-band energy threshold */
9014 21, /* 21/32 in-band to broad-band ratio */
9015 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9016 },
9017 { /* f300_425[] 16 */
9018 30741, /* A1 = 1.876282 */
9019 -31475, /* A2 = -0.960541 */
9020 -703, /* B2 = -0.021484 */
9021 0, /* B1 = 0 */
9022 703, /* B0 = 0.021484 */
9023 30688, /* A1 = 1.873047 */
9024 -32248, /* A2 = -0.984161 */
9025 14542, /* B2 = 0.443787 */
9026 -13523, /* B1 = -0.825439 */
9027 14542, /* B0 = 0.443817 */
9028 31494, /* A1 = 1.922302 */
9029 -32366, /* A2 = -0.987762 */
9030 21577, /* B2 = 0.658508 */
9031 -21013, /* B1 = -1.282532 */
9032 21577, /* B0 = 0.658508 */
9033 7, /* Internal filter scaling */
9034 159, /* Minimum in-band energy threshold */
9035 21, /* 21/32 in-band to broad-band ratio */
9036 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9037 },
9038 { /* f330_440[] 17 */
9039 30627, /* A1 = 1.869324 */
9040 -31338, /* A2 = -0.95636 */
9041 -843, /* B2 = -0.025749 */
9042 0, /* B1 = 0 */
9043 843, /* B0 = 0.025749 */
9044 30550, /* A1 = 1.864685 */
9045 -32221, /* A2 = -0.983337 */
9046 13594, /* B2 = 0.414886 */
9047 -12589, /* B1 = -0.768402 */
9048 13594, /* B0 = 0.414886 */
9049 31488, /* A1 = 1.921936 */
9050 -32358, /* A2 = -0.987518 */
9051 24684, /* B2 = 0.753296 */
9052 -24029, /* B1 = -1.466614 */
9053 24684, /* B0 = 0.753296 */
9054 7, /* Internal filter scaling */
9055 159, /* Minimum in-band energy threshold */
9056 21, /* 21/32 in-band to broad-band ratio */
9057 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9058 },
9059 { /* f340 18 */
9060 31546, /* A1 = -1.925476 */
9061 -32646, /* A2 = 0.996277 */
9062 -445, /* B2 = -0.013588 */
9063 0, /* B1 = 0.000000 */
9064 445, /* B0 = 0.013588 */
9065 31551, /* A1 = -1.925781 */
9066 -32713, /* A2 = 0.998352 */
9067 23884, /* B2 = 0.728882 */
9068 -22979, /* B1 = -1.402527 */
9069 23884, /* B0 = 0.728882 */
9070 31606, /* A1 = -1.929138 */
9071 -32715, /* A2 = 0.998413 */
9072 863, /* B2 = 0.026367 */
9073 -835, /* B1 = -0.050985 */
9074 863, /* B0 = 0.026367 */
9075 5, /* Internal filter scaling */
9076 159, /* Minimum in-band energy threshold */
9077 21, /* 21/32 in-band to broad-band ratio */
9078 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9079 },
9080 { /* f350_400[] 19 */
9081 31006, /* A1 = 1.892517 */
9082 -32029, /* A2 = -0.977448 */
9083 -461, /* B2 = -0.014096 */
9084 0, /* B1 = 0 */
9085 461, /* B0 = 0.014096 */
9086 30999, /* A1 = 1.892029 */
9087 -32487, /* A2 = -0.991455 */
9088 11325, /* B2 = 0.345612 */
9089 -10682, /* B1 = -0.651978 */
9090 11325, /* B0 = 0.345612 */
9091 31441, /* A1 = 1.919067 */
9092 -32526, /* A2 = -0.992615 */
9093 24324, /* B2 = 0.74231 */
9094 -23535, /* B1 = -1.436523 */
9095 24324, /* B0 = 0.74231 */
9096 7, /* Internal filter scaling */
9097 159, /* Minimum in-band energy threshold */
9098 21, /* 21/32 in-band to broad-band ratio */
9099 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9100 },
9101 { /* f350_440[] */
9102 30634, /* A1 = 1.869751 */
9103 -31533, /* A2 = -0.962341 */
9104 -680, /* B2 = -0.020782 */
9105 0, /* B1 = 0 */
9106 680, /* B0 = 0.020782 */
9107 30571, /* A1 = 1.865906 */
9108 -32277, /* A2 = -0.985016 */
9109 12894, /* B2 = 0.393524 */
9110 -11945, /* B1 = -0.729065 */
9111 12894, /* B0 = 0.393524 */
9112 31367, /* A1 = 1.91449 */
9113 -32379, /* A2 = -0.988129 */
9114 23820, /* B2 = 0.726929 */
9115 -23104, /* B1 = -1.410217 */
9116 23820, /* B0 = 0.726929 */
9117 7, /* Internal filter scaling */
9118 159, /* Minimum in-band energy threshold */
9119 21, /* 21/32 in-band to broad-band ratio */
9120 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9121 },
9122 { /* f350_450[] */
9123 30552, /* A1 = 1.864807 */
9124 -31434, /* A2 = -0.95929 */
9125 -690, /* B2 = -0.021066 */
9126 0, /* B1 = 0 */
9127 690, /* B0 = 0.021066 */
9128 30472, /* A1 = 1.859924 */
9129 -32248, /* A2 = -0.984161 */
9130 13385, /* B2 = 0.408478 */
9131 -12357, /* B1 = -0.754242 */
9132 13385, /* B0 = 0.408478 */
9133 31358, /* A1 = 1.914001 */
9134 -32366, /* A2 = -0.987732 */
9135 26488, /* B2 = 0.80835 */
9136 -25692, /* B1 = -1.568176 */
9137 26490, /* B0 = 0.808411 */
9138 7, /* Internal filter scaling */
9139 159, /* Minimum in-band energy threshold */
9140 21, /* 21/32 in-band to broad-band ratio */
9141 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9142 },
9143 { /* f360 */
9144 31397, /* A1 = -1.916321 */
9145 -32623, /* A2 = 0.995605 */
9146 -117, /* B2 = -0.003598 */
9147 0, /* B1 = 0.000000 */
9148 117, /* B0 = 0.003598 */
9149 31403, /* A1 = -1.916687 */
9150 -32700, /* A2 = 0.997925 */
9151 3388, /* B2 = 0.103401 */
9152 -3240, /* B1 = -0.197784 */
9153 3388, /* B0 = 0.103401 */
9154 31463, /* A1 = -1.920410 */
9155 -32702, /* A2 = 0.997986 */
9156 13346, /* B2 = 0.407288 */
9157 -12863, /* B1 = -0.785126 */
9158 13346, /* B0 = 0.407288 */
9159 5, /* Internal filter scaling */
9160 159, /* Minimum in-band energy threshold */
9161 21, /* 21/32 in-band to broad-band ratio */
9162 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9163 },
9164 { /* f380_420[] */
9165 30831, /* A1 = 1.881775 */
9166 -32064, /* A2 = -0.978546 */
9167 -367, /* B2 = -0.01122 */
9168 0, /* B1 = 0 */
9169 367, /* B0 = 0.01122 */
9170 30813, /* A1 = 1.880737 */
9171 -32456, /* A2 = -0.990509 */
9172 11068, /* B2 = 0.337769 */
9173 -10338, /* B1 = -0.631042 */
9174 11068, /* B0 = 0.337769 */
9175 31214, /* A1 = 1.905212 */
9176 -32491, /* A2 = -0.991577 */
9177 16374, /* B2 = 0.499695 */
9178 -15781, /* B1 = -0.963196 */
9179 16374, /* B0 = 0.499695 */
9180 7, /* Internal filter scaling */
9181 159, /* Minimum in-band energy threshold */
9182 21, /* 21/32 in-band to broad-band ratio */
9183 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9184 },
9185 { /* f392 */
9186 31152, /* A1 = -1.901428 */
9187 -32613, /* A2 = 0.995300 */
9188 -314, /* B2 = -0.009605 */
9189 0, /* B1 = 0.000000 */
9190 314, /* B0 = 0.009605 */
9191 31156, /* A1 = -1.901672 */
9192 -32694, /* A2 = 0.997742 */
9193 28847, /* B2 = 0.880371 */
9194 -2734, /* B1 = -0.166901 */
9195 28847, /* B0 = 0.880371 */
9196 31225, /* A1 = -1.905823 */
9197 -32696, /* A2 = 0.997803 */
9198 462, /* B2 = 0.014108 */
9199 -442, /* B1 = -0.027019 */
9200 462, /* B0 = 0.014108 */
9201 5, /* Internal filter scaling */
9202 159, /* Minimum in-band energy threshold */
9203 21, /* 21/32 in-band to broad-band ratio */
9204 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9205 },
9206 { /* f400_425[] */
9207 30836, /* A1 = 1.882141 */
9208 -32296, /* A2 = -0.985596 */
9209 -324, /* B2 = -0.009903 */
9210 0, /* B1 = 0 */
9211 324, /* B0 = 0.009903 */
9212 30825, /* A1 = 1.881409 */
9213 -32570, /* A2 = -0.993958 */
9214 16847, /* B2 = 0.51416 */
9215 -15792, /* B1 = -0.963898 */
9216 16847, /* B0 = 0.51416 */
9217 31106, /* A1 = 1.89856 */
9218 -32584, /* A2 = -0.994415 */
9219 9579, /* B2 = 0.292328 */
9220 -9164, /* B1 = -0.559357 */
9221 9579, /* B0 = 0.292328 */
9222 7, /* Internal filter scaling */
9223 159, /* Minimum in-band energy threshold */
9224 21, /* 21/32 in-band to broad-band ratio */
9225 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9226 },
9227 { /* f400_440[] */
9228 30702, /* A1 = 1.873962 */
9229 -32134, /* A2 = -0.980682 */
9230 -517, /* B2 = -0.015793 */
9231 0, /* B1 = 0 */
9232 517, /* B0 = 0.015793 */
9233 30676, /* A1 = 1.872375 */
9234 -32520, /* A2 = -0.992462 */
9235 8144, /* B2 = 0.24855 */
9236 -7596, /* B1 = -0.463684 */
9237 8144, /* B0 = 0.24855 */
9238 31084, /* A1 = 1.897217 */
9239 -32547, /* A2 = -0.993256 */
9240 22713, /* B2 = 0.693176 */
9241 -21734, /* B1 = -1.326599 */
9242 22713, /* B0 = 0.693176 */
9243 7, /* Internal filter scaling */
9244 159, /* Minimum in-band energy threshold */
9245 21, /* 21/32 in-band to broad-band ratio */
9246 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9247 },
9248 { /* f400_450[] */
9249 30613, /* A1 = 1.86853 */
9250 -32031, /* A2 = -0.977509 */
9251 -618, /* B2 = -0.018866 */
9252 0, /* B1 = 0 */
9253 618, /* B0 = 0.018866 */
9254 30577, /* A1 = 1.866272 */
9255 -32491, /* A2 = -0.991577 */
9256 9612, /* B2 = 0.293335 */
9257 -8935, /* B1 = -0.54541 */
9258 9612, /* B0 = 0.293335 */
9259 31071, /* A1 = 1.896484 */
9260 -32524, /* A2 = -0.992584 */
9261 21596, /* B2 = 0.659058 */
9262 -20667, /* B1 = -1.261414 */
9263 21596, /* B0 = 0.659058 */
9264 7, /* Internal filter scaling */
9265 159, /* Minimum in-band energy threshold */
9266 21, /* 21/32 in-band to broad-band ratio */
9267 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9268 },
9269 { /* f420 */
9270 30914, /* A1 = -1.886841 */
9271 -32584, /* A2 = 0.994385 */
9272 -426, /* B2 = -0.013020 */
9273 0, /* B1 = 0.000000 */
9274 426, /* B0 = 0.013020 */
9275 30914, /* A1 = -1.886841 */
9276 -32679, /* A2 = 0.997314 */
9277 17520, /* B2 = 0.534668 */
9278 -16471, /* B1 = -1.005310 */
9279 17520, /* B0 = 0.534668 */
9280 31004, /* A1 = -1.892334 */
9281 -32683, /* A2 = 0.997406 */
9282 819, /* B2 = 0.025023 */
9283 -780, /* B1 = -0.047619 */
9284 819, /* B0 = 0.025023 */
9285 5, /* Internal filter scaling */
9286 159, /* Minimum in-band energy threshold */
9287 21, /* 21/32 in-band to broad-band ratio */
9288 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9289 },
9290 #if 0
9291 { /* f425 */
9292 30881, /* A1 = -1.884827 */
9293 -32603, /* A2 = 0.994965 */
9294 -496, /* B2 = -0.015144 */
9295 0, /* B1 = 0.000000 */
9296 496, /* B0 = 0.015144 */
9297 30880, /* A1 = -1.884766 */
9298 -32692, /* A2 = 0.997711 */
9299 24767, /* B2 = 0.755859 */
9300 -23290, /* B1 = -1.421509 */
9301 24767, /* B0 = 0.755859 */
9302 30967, /* A1 = -1.890076 */
9303 -32694, /* A2 = 0.997772 */
9304 728, /* B2 = 0.022232 */
9305 -691, /* B1 = -0.042194 */
9306 728, /* B0 = 0.022232 */
9307 5, /* Internal filter scaling */
9308 159, /* Minimum in-band energy threshold */
9309 21, /* 21/32 in-band to broad-band ratio */
9310 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9311 },
9312 #else
9313 {
9314 30850,
9315 -32534,
9316 -504,
9317 0,
9318 504,
9319 30831,
9320 -32669,
9321 24303,
9322 -22080,
9323 24303,
9324 30994,
9325 -32673,
9326 1905,
9327 -1811,
9328 1905,
9329 5,
9330 129,
9331 17,
9332 0xff5
9333 },
9334 #endif
9335 { /* f425_450[] */
9336 30646, /* A1 = 1.870544 */
9337 -32327, /* A2 = -0.986572 */
9338 -287, /* B2 = -0.008769 */
9339 0, /* B1 = 0 */
9340 287, /* B0 = 0.008769 */
9341 30627, /* A1 = 1.869324 */
9342 -32607, /* A2 = -0.995087 */
9343 13269, /* B2 = 0.404968 */
9344 -12376, /* B1 = -0.755432 */
9345 13269, /* B0 = 0.404968 */
9346 30924, /* A1 = 1.887512 */
9347 -32619, /* A2 = -0.995453 */
9348 19950, /* B2 = 0.608826 */
9349 -18940, /* B1 = -1.156006 */
9350 19950, /* B0 = 0.608826 */
9351 7, /* Internal filter scaling */
9352 159, /* Minimum in-band energy threshold */
9353 21, /* 21/32 in-band to broad-band ratio */
9354 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9355 },
9356 { /* f425_475[] */
9357 30396, /* A1 = 1.855225 */
9358 -32014, /* A2 = -0.97699 */
9359 -395, /* B2 = -0.012055 */
9360 0, /* B1 = 0 */
9361 395, /* B0 = 0.012055 */
9362 30343, /* A1 = 1.85199 */
9363 -32482, /* A2 = -0.991302 */
9364 17823, /* B2 = 0.543945 */
9365 -16431, /* B1 = -1.002869 */
9366 17823, /* B0 = 0.543945 */
9367 30872, /* A1 = 1.884338 */
9368 -32516, /* A2 = -0.99231 */
9369 18124, /* B2 = 0.553101 */
9370 -17246, /* B1 = -1.052673 */
9371 18124, /* B0 = 0.553101 */
9372 7, /* Internal filter scaling */
9373 159, /* Minimum in-band energy threshold */
9374 21, /* 21/32 in-band to broad-band ratio */
9375 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9376 },
9377 { /* f435 */
9378 30796, /* A1 = -1.879639 */
9379 -32603, /* A2 = 0.994965 */
9380 -254, /* B2 = -0.007762 */
9381 0, /* B1 = 0.000000 */
9382 254, /* B0 = 0.007762 */
9383 30793, /* A1 = -1.879456 */
9384 -32692, /* A2 = 0.997711 */
9385 18934, /* B2 = 0.577820 */
9386 -17751, /* B1 = -1.083496 */
9387 18934, /* B0 = 0.577820 */
9388 30882, /* A1 = -1.884888 */
9389 -32694, /* A2 = 0.997772 */
9390 1858, /* B2 = 0.056713 */
9391 -1758, /* B1 = -0.107357 */
9392 1858, /* B0 = 0.056713 */
9393 5, /* Internal filter scaling */
9394 159, /* Minimum in-band energy threshold */
9395 21, /* 21/32 in-band to broad-band ratio */
9396 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9397 },
9398 { /* f440_450[] */
9399 30641, /* A1 = 1.870239 */
9400 -32458, /* A2 = -0.99057 */
9401 -155, /* B2 = -0.004735 */
9402 0, /* B1 = 0 */
9403 155, /* B0 = 0.004735 */
9404 30631, /* A1 = 1.869568 */
9405 -32630, /* A2 = -0.995789 */
9406 11453, /* B2 = 0.349548 */
9407 -10666, /* B1 = -0.651001 */
9408 11453, /* B0 = 0.349548 */
9409 30810, /* A1 = 1.880554 */
9410 -32634, /* A2 = -0.995941 */
9411 12237, /* B2 = 0.373474 */
9412 -11588, /* B1 = -0.707336 */
9413 12237, /* B0 = 0.373474 */
9414 7, /* Internal filter scaling */
9415 159, /* Minimum in-band energy threshold */
9416 21, /* 21/32 in-band to broad-band ratio */
9417 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9418 },
9419 { /* f440_480[] */
9420 30367, /* A1 = 1.853455 */
9421 -32147, /* A2 = -0.981079 */
9422 -495, /* B2 = -0.015113 */
9423 0, /* B1 = 0 */
9424 495, /* B0 = 0.015113 */
9425 30322, /* A1 = 1.850769 */
9426 -32543, /* A2 = -0.993134 */
9427 10031, /* B2 = 0.306152 */
9428 -9252, /* B1 = -0.564728 */
9429 10031, /* B0 = 0.306152 */
9430 30770, /* A1 = 1.878052 */
9431 -32563, /* A2 = -0.993774 */
9432 22674, /* B2 = 0.691956 */
9433 -21465, /* B1 = -1.31012 */
9434 22674, /* B0 = 0.691956 */
9435 7, /* Internal filter scaling */
9436 159, /* Minimum in-band energy threshold */
9437 21, /* 21/32 in-band to broad-band ratio */
9438 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9439 },
9440 { /* f445 */
9441 30709, /* A1 = -1.874329 */
9442 -32603, /* A2 = 0.994965 */
9443 -83, /* B2 = -0.002545 */
9444 0, /* B1 = 0.000000 */
9445 83, /* B0 = 0.002545 */
9446 30704, /* A1 = -1.874084 */
9447 -32692, /* A2 = 0.997711 */
9448 10641, /* B2 = 0.324738 */
9449 -9947, /* B1 = -0.607147 */
9450 10641, /* B0 = 0.324738 */
9451 30796, /* A1 = -1.879639 */
9452 -32694, /* A2 = 0.997772 */
9453 10079, /* B2 = 0.307587 */
9454 9513, /* B1 = 0.580688 */
9455 10079, /* B0 = 0.307587 */
9456 5, /* Internal filter scaling */
9457 159, /* Minimum in-band energy threshold */
9458 21, /* 21/32 in-band to broad-band ratio */
9459 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9460 },
9461 { /* f450 */
9462 30664, /* A1 = -1.871643 */
9463 -32603, /* A2 = 0.994965 */
9464 -164, /* B2 = -0.005029 */
9465 0, /* B1 = 0.000000 */
9466 164, /* B0 = 0.005029 */
9467 30661, /* A1 = -1.871399 */
9468 -32692, /* A2 = 0.997711 */
9469 15294, /* B2 = 0.466736 */
9470 -14275, /* B1 = -0.871307 */
9471 15294, /* B0 = 0.466736 */
9472 30751, /* A1 = -1.876953 */
9473 -32694, /* A2 = 0.997772 */
9474 3548, /* B2 = 0.108284 */
9475 -3344, /* B1 = -0.204155 */
9476 3548, /* B0 = 0.108284 */
9477 5, /* Internal filter scaling */
9478 159, /* Minimum in-band energy threshold */
9479 21, /* 21/32 in-band to broad-band ratio */
9480 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9481 },
9482 { /* f452 */
9483 30653, /* A1 = -1.870911 */
9484 -32615, /* A2 = 0.995361 */
9485 -209, /* B2 = -0.006382 */
9486 0, /* B1 = 0.000000 */
9487 209, /* B0 = 0.006382 */
9488 30647, /* A1 = -1.870605 */
9489 -32702, /* A2 = 0.997986 */
9490 18971, /* B2 = 0.578979 */
9491 -17716, /* B1 = -1.081299 */
9492 18971, /* B0 = 0.578979 */
9493 30738, /* A1 = -1.876099 */
9494 -32702, /* A2 = 0.998016 */
9495 2967, /* B2 = 0.090561 */
9496 -2793, /* B1 = -0.170502 */
9497 2967, /* B0 = 0.090561 */
9498 5, /* Internal filter scaling */
9499 159, /* Minimum in-band energy threshold */
9500 21, /* 21/32 in-band to broad-band ratio */
9501 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9502 },
9503 { /* f475 */
9504 30437, /* A1 = -1.857727 */
9505 -32603, /* A2 = 0.994965 */
9506 -264, /* B2 = -0.008062 */
9507 0, /* B1 = 0.000000 */
9508 264, /* B0 = 0.008062 */
9509 30430, /* A1 = -1.857300 */
9510 -32692, /* A2 = 0.997711 */
9511 21681, /* B2 = 0.661682 */
9512 -20082, /* B1 = -1.225708 */
9513 21681, /* B0 = 0.661682 */
9514 30526, /* A1 = -1.863220 */
9515 -32694, /* A2 = 0.997742 */
9516 1559, /* B2 = 0.047600 */
9517 -1459, /* B1 = -0.089096 */
9518 1559, /* B0 = 0.047600 */
9519 5, /* Internal filter scaling */
9520 159, /* Minimum in-band energy threshold */
9521 21, /* 21/32 in-band to broad-band ratio */
9522 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9523 },
9524 { /* f480_620[] */
9525 28975, /* A1 = 1.768494 */
9526 -30955, /* A2 = -0.944672 */
9527 -1026, /* B2 = -0.03133 */
9528 0, /* B1 = 0 */
9529 1026, /* B0 = 0.03133 */
9530 28613, /* A1 = 1.746399 */
9531 -32089, /* A2 = -0.979309 */
9532 14214, /* B2 = 0.433807 */
9533 -12202, /* B1 = -0.744812 */
9534 14214, /* B0 = 0.433807 */
9535 30243, /* A1 = 1.845947 */
9536 -32238, /* A2 = -0.983856 */
9537 24825, /* B2 = 0.757629 */
9538 -23402, /* B1 = -1.428345 */
9539 24825, /* B0 = 0.757629 */
9540 7, /* Internal filter scaling */
9541 159, /* Minimum in-band energy threshold */
9542 21, /* 21/32 in-band to broad-band ratio */
9543 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9544 },
9545 { /* f494 */
9546 30257, /* A1 = -1.846741 */
9547 -32605, /* A2 = 0.995056 */
9548 -249, /* B2 = -0.007625 */
9549 0, /* B1 = 0.000000 */
9550 249, /* B0 = 0.007625 */
9551 30247, /* A1 = -1.846191 */
9552 -32694, /* A2 = 0.997772 */
9553 18088, /* B2 = 0.552002 */
9554 -16652, /* B1 = -1.016418 */
9555 18088, /* B0 = 0.552002 */
9556 30348, /* A1 = -1.852295 */
9557 -32696, /* A2 = 0.997803 */
9558 2099, /* B2 = 0.064064 */
9559 -1953, /* B1 = -0.119202 */
9560 2099, /* B0 = 0.064064 */
9561 5, /* Internal filter scaling */
9562 159, /* Minimum in-band energy threshold */
9563 21, /* 21/32 in-band to broad-band ratio */
9564 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9565 },
9566 { /* f500 */
9567 30202, /* A1 = -1.843431 */
9568 -32624, /* A2 = 0.995622 */
9569 -413, /* B2 = -0.012622 */
9570 0, /* B1 = 0.000000 */
9571 413, /* B0 = 0.012622 */
9572 30191, /* A1 = -1.842721 */
9573 -32714, /* A2 = 0.998364 */
9574 25954, /* B2 = 0.792057 */
9575 -23890, /* B1 = -1.458131 */
9576 25954, /* B0 = 0.792057 */
9577 30296, /* A1 = -1.849172 */
9578 -32715, /* A2 = 0.998397 */
9579 2007, /* B2 = 0.061264 */
9580 -1860, /* B1 = -0.113568 */
9581 2007, /* B0 = 0.061264 */
9582 5, /* Internal filter scaling */
9583 159, /* Minimum in-band energy threshold */
9584 21, /* 21/32 in-band to broad-band ratio */
9585 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9586 },
9587 { /* f520 */
9588 30001, /* A1 = -1.831116 */
9589 -32613, /* A2 = 0.995270 */
9590 -155, /* B2 = -0.004750 */
9591 0, /* B1 = 0.000000 */
9592 155, /* B0 = 0.004750 */
9593 29985, /* A1 = -1.830200 */
9594 -32710, /* A2 = 0.998260 */
9595 6584, /* B2 = 0.200928 */
9596 -6018, /* B1 = -0.367355 */
9597 6584, /* B0 = 0.200928 */
9598 30105, /* A1 = -1.837524 */
9599 -32712, /* A2 = 0.998291 */
9600 23812, /* B2 = 0.726685 */
9601 -21936, /* B1 = -1.338928 */
9602 23812, /* B0 = 0.726685 */
9603 5, /* Internal filter scaling */
9604 159, /* Minimum in-band energy threshold */
9605 21, /* 21/32 in-band to broad-band ratio */
9606 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9607 },
9608 { /* f523 */
9609 29964, /* A1 = -1.828918 */
9610 -32601, /* A2 = 0.994904 */
9611 -101, /* B2 = -0.003110 */
9612 0, /* B1 = 0.000000 */
9613 101, /* B0 = 0.003110 */
9614 29949, /* A1 = -1.827942 */
9615 -32700, /* A2 = 0.997925 */
9616 11041, /* B2 = 0.336975 */
9617 -10075, /* B1 = -0.614960 */
9618 11041, /* B0 = 0.336975 */
9619 30070, /* A1 = -1.835388 */
9620 -32702, /* A2 = 0.997986 */
9621 16762, /* B2 = 0.511536 */
9622 -15437, /* B1 = -0.942230 */
9623 16762, /* B0 = 0.511536 */
9624 5, /* Internal filter scaling */
9625 159, /* Minimum in-band energy threshold */
9626 21, /* 21/32 in-band to broad-band ratio */
9627 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9628 },
9629 { /* f525 */
9630 29936, /* A1 = -1.827209 */
9631 -32584, /* A2 = 0.994415 */
9632 -91, /* B2 = -0.002806 */
9633 0, /* B1 = 0.000000 */
9634 91, /* B0 = 0.002806 */
9635 29921, /* A1 = -1.826233 */
9636 -32688, /* A2 = 0.997559 */
9637 11449, /* B2 = 0.349396 */
9638 -10426, /* B1 = -0.636383 */
9639 11449, /* B0 = 0.349396 */
9640 30045, /* A1 = -1.833862 */
9641 -32688, /* A2 = 0.997589 */
9642 13055, /* B2 = 0.398407 */
9643 -12028, /* B1 = -0.734161 */
9644 13055, /* B0 = 0.398407 */
9645 5, /* Internal filter scaling */
9646 159, /* Minimum in-band energy threshold */
9647 21, /* 21/32 in-band to broad-band ratio */
9648 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9649 },
9650 { /* f540_660[] */
9651 28499, /* A1 = 1.739441 */
9652 -31129, /* A2 = -0.949982 */
9653 -849, /* B2 = -0.025922 */
9654 0, /* B1 = 0 */
9655 849, /* B0 = 0.025922 */
9656 28128, /* A1 = 1.716797 */
9657 -32130, /* A2 = -0.98056 */
9658 14556, /* B2 = 0.444214 */
9659 -12251, /* B1 = -0.747772 */
9660 14556, /* B0 = 0.444244 */
9661 29667, /* A1 = 1.81073 */
9662 -32244, /* A2 = -0.984039 */
9663 23038, /* B2 = 0.703064 */
9664 -21358, /* B1 = -1.303589 */
9665 23040, /* B0 = 0.703125 */
9666 7, /* Internal filter scaling */
9667 159, /* Minimum in-band energy threshold */
9668 21, /* 21/32 in-band to broad-band ratio */
9669 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9670 },
9671 { /* f587 */
9672 29271, /* A1 = -1.786560 */
9673 -32599, /* A2 = 0.994873 */
9674 -490, /* B2 = -0.014957 */
9675 0, /* B1 = 0.000000 */
9676 490, /* B0 = 0.014957 */
9677 29246, /* A1 = -1.785095 */
9678 -32700, /* A2 = 0.997925 */
9679 28961, /* B2 = 0.883850 */
9680 -25796, /* B1 = -1.574463 */
9681 28961, /* B0 = 0.883850 */
9682 29383, /* A1 = -1.793396 */
9683 -32700, /* A2 = 0.997955 */
9684 1299, /* B2 = 0.039650 */
9685 -1169, /* B1 = -0.071396 */
9686 1299, /* B0 = 0.039650 */
9687 5, /* Internal filter scaling */
9688 159, /* Minimum in-band energy threshold */
9689 21, /* 21/32 in-band to broad-band ratio */
9690 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9691 },
9692 { /* f590 */
9693 29230, /* A1 = -1.784058 */
9694 -32584, /* A2 = 0.994415 */
9695 -418, /* B2 = -0.012757 */
9696 0, /* B1 = 0.000000 */
9697 418, /* B0 = 0.012757 */
9698 29206, /* A1 = -1.782593 */
9699 -32688, /* A2 = 0.997559 */
9700 36556, /* B2 = 1.115601 */
9701 -32478, /* B1 = -1.982300 */
9702 36556, /* B0 = 1.115601 */
9703 29345, /* A1 = -1.791077 */
9704 -32688, /* A2 = 0.997589 */
9705 897, /* B2 = 0.027397 */
9706 -808, /* B1 = -0.049334 */
9707 897, /* B0 = 0.027397 */
9708 5, /* Internal filter scaling */
9709 159, /* Minimum in-band energy threshold */
9710 21, /* 21/32 in-band to broad-band ratio */
9711 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9712 },
9713 { /* f600 */
9714 29116, /* A1 = -1.777100 */
9715 -32603, /* A2 = 0.994965 */
9716 -165, /* B2 = -0.005039 */
9717 0, /* B1 = 0.000000 */
9718 165, /* B0 = 0.005039 */
9719 29089, /* A1 = -1.775452 */
9720 -32708, /* A2 = 0.998199 */
9721 6963, /* B2 = 0.212494 */
9722 -6172, /* B1 = -0.376770 */
9723 6963, /* B0 = 0.212494 */
9724 29237, /* A1 = -1.784485 */
9725 -32710, /* A2 = 0.998230 */
9726 24197, /* B2 = 0.738464 */
9727 -21657, /* B1 = -1.321899 */
9728 24197, /* B0 = 0.738464 */
9729 5, /* Internal filter scaling */
9730 159, /* Minimum in-band energy threshold */
9731 21, /* 21/32 in-band to broad-band ratio */
9732 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9733 },
9734 { /* f660 */
9735 28376, /* A1 = -1.731934 */
9736 -32567, /* A2 = 0.993896 */
9737 -363, /* B2 = -0.011102 */
9738 0, /* B1 = 0.000000 */
9739 363, /* B0 = 0.011102 */
9740 28337, /* A1 = -1.729614 */
9741 -32683, /* A2 = 0.997434 */
9742 21766, /* B2 = 0.664246 */
9743 -18761, /* B1 = -1.145081 */
9744 21766, /* B0 = 0.664246 */
9745 28513, /* A1 = -1.740356 */
9746 -32686, /* A2 = 0.997498 */
9747 2509, /* B2 = 0.076584 */
9748 -2196, /* B1 = -0.134041 */
9749 2509, /* B0 = 0.076584 */
9750 5, /* Internal filter scaling */
9751 159, /* Minimum in-band energy threshold */
9752 21, /* 21/32 in-band to broad-band ratio */
9753 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9754 },
9755 { /* f700 */
9756 27844, /* A1 = -1.699463 */
9757 -32563, /* A2 = 0.993744 */
9758 -366, /* B2 = -0.011187 */
9759 0, /* B1 = 0.000000 */
9760 366, /* B0 = 0.011187 */
9761 27797, /* A1 = -1.696655 */
9762 -32686, /* A2 = 0.997498 */
9763 22748, /* B2 = 0.694214 */
9764 -19235, /* B1 = -1.174072 */
9765 22748, /* B0 = 0.694214 */
9766 27995, /* A1 = -1.708740 */
9767 -32688, /* A2 = 0.997559 */
9768 2964, /* B2 = 0.090477 */
9769 -2546, /* B1 = -0.155449 */
9770 2964, /* B0 = 0.090477 */
9771 5, /* Internal filter scaling */
9772 159, /* Minimum in-band energy threshold */
9773 21, /* 21/32 in-band to broad-band ratio */
9774 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9775 },
9776 { /* f740 */
9777 27297, /* A1 = -1.666077 */
9778 -32551, /* A2 = 0.993408 */
9779 -345, /* B2 = -0.010540 */
9780 0, /* B1 = 0.000000 */
9781 345, /* B0 = 0.010540 */
9782 27240, /* A1 = -1.662598 */
9783 -32683, /* A2 = 0.997406 */
9784 22560, /* B2 = 0.688477 */
9785 -18688, /* B1 = -1.140625 */
9786 22560, /* B0 = 0.688477 */
9787 27461, /* A1 = -1.676147 */
9788 -32684, /* A2 = 0.997467 */
9789 3541, /* B2 = 0.108086 */
9790 -2985, /* B1 = -0.182220 */
9791 3541, /* B0 = 0.108086 */
9792 5, /* Internal filter scaling */
9793 159, /* Minimum in-band energy threshold */
9794 21, /* 21/32 in-band to broad-band ratio */
9795 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9796 },
9797 { /* f750 */
9798 27155, /* A1 = -1.657410 */
9799 -32551, /* A2 = 0.993408 */
9800 -462, /* B2 = -0.014117 */
9801 0, /* B1 = 0.000000 */
9802 462, /* B0 = 0.014117 */
9803 27097, /* A1 = -1.653870 */
9804 -32683, /* A2 = 0.997406 */
9805 32495, /* B2 = 0.991699 */
9806 -26776, /* B1 = -1.634338 */
9807 32495, /* B0 = 0.991699 */
9808 27321, /* A1 = -1.667542 */
9809 -32684, /* A2 = 0.997467 */
9810 1835, /* B2 = 0.056007 */
9811 -1539, /* B1 = -0.093948 */
9812 1835, /* B0 = 0.056007 */
9813 5, /* Internal filter scaling */
9814 159, /* Minimum in-band energy threshold */
9815 21, /* 21/32 in-band to broad-band ratio */
9816 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9817 },
9818 { /* f750_1450[] */
9819 19298, /* A1 = 1.177917 */
9820 -24471, /* A2 = -0.746796 */
9821 -4152, /* B2 = -0.126709 */
9822 0, /* B1 = 0 */
9823 4152, /* B0 = 0.126709 */
9824 12902, /* A1 = 0.787476 */
9825 -29091, /* A2 = -0.887817 */
9826 12491, /* B2 = 0.38121 */
9827 -1794, /* B1 = -0.109528 */
9828 12494, /* B0 = 0.381317 */
9829 26291, /* A1 = 1.604736 */
9830 -30470, /* A2 = -0.929901 */
9831 28859, /* B2 = 0.880737 */
9832 -26084, /* B1 = -1.592102 */
9833 28861, /* B0 = 0.880798 */
9834 7, /* Internal filter scaling */
9835 159, /* Minimum in-band energy threshold */
9836 21, /* 21/32 in-band to broad-band ratio */
9837 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9838 },
9839 { /* f770 */
9840 26867, /* A1 = -1.639832 */
9841 -32551, /* A2 = 0.993408 */
9842 -123, /* B2 = -0.003755 */
9843 0, /* B1 = 0.000000 */
9844 123, /* B0 = 0.003755 */
9845 26805, /* A1 = -1.636108 */
9846 -32683, /* A2 = 0.997406 */
9847 17297, /* B2 = 0.527863 */
9848 -14096, /* B1 = -0.860382 */
9849 17297, /* B0 = 0.527863 */
9850 27034, /* A1 = -1.650085 */
9851 -32684, /* A2 = 0.997467 */
9852 12958, /* B2 = 0.395477 */
9853 -10756, /* B1 = -0.656525 */
9854 12958, /* B0 = 0.395477 */
9855 5, /* Internal filter scaling */
9856 159, /* Minimum in-band energy threshold */
9857 21, /* 21/32 in-band to broad-band ratio */
9858 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9859 },
9860 { /* f800 */
9861 26413, /* A1 = -1.612122 */
9862 -32547, /* A2 = 0.993286 */
9863 -223, /* B2 = -0.006825 */
9864 0, /* B1 = 0.000000 */
9865 223, /* B0 = 0.006825 */
9866 26342, /* A1 = -1.607849 */
9867 -32686, /* A2 = 0.997498 */
9868 6391, /* B2 = 0.195053 */
9869 -5120, /* B1 = -0.312531 */
9870 6391, /* B0 = 0.195053 */
9871 26593, /* A1 = -1.623108 */
9872 -32688, /* A2 = 0.997559 */
9873 23681, /* B2 = 0.722717 */
9874 -19328, /* B1 = -1.179688 */
9875 23681, /* B0 = 0.722717 */
9876 5, /* Internal filter scaling */
9877 159, /* Minimum in-band energy threshold */
9878 21, /* 21/32 in-band to broad-band ratio */
9879 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9880 },
9881 { /* f816 */
9882 26168, /* A1 = -1.597209 */
9883 -32528, /* A2 = 0.992706 */
9884 -235, /* B2 = -0.007182 */
9885 0, /* B1 = 0.000000 */
9886 235, /* B0 = 0.007182 */
9887 26092, /* A1 = -1.592590 */
9888 -32675, /* A2 = 0.997192 */
9889 20823, /* B2 = 0.635498 */
9890 -16510, /* B1 = -1.007751 */
9891 20823, /* B0 = 0.635498 */
9892 26363, /* A1 = -1.609070 */
9893 -32677, /* A2 = 0.997253 */
9894 6739, /* B2 = 0.205688 */
9895 -5459, /* B1 = -0.333206 */
9896 6739, /* B0 = 0.205688 */
9897 5, /* Internal filter scaling */
9898 159, /* Minimum in-band energy threshold */
9899 21, /* 21/32 in-band to broad-band ratio */
9900 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9901 },
9902 { /* f850 */
9903 25641, /* A1 = -1.565063 */
9904 -32536, /* A2 = 0.992950 */
9905 -121, /* B2 = -0.003707 */
9906 0, /* B1 = 0.000000 */
9907 121, /* B0 = 0.003707 */
9908 25560, /* A1 = -1.560059 */
9909 -32684, /* A2 = 0.997437 */
9910 18341, /* B2 = 0.559753 */
9911 -14252, /* B1 = -0.869904 */
9912 18341, /* B0 = 0.559753 */
9913 25837, /* A1 = -1.577026 */
9914 -32684, /* A2 = 0.997467 */
9915 16679, /* B2 = 0.509003 */
9916 -13232, /* B1 = -0.807648 */
9917 16679, /* B0 = 0.509003 */
9918 5, /* Internal filter scaling */
9919 159, /* Minimum in-band energy threshold */
9920 21, /* 21/32 in-band to broad-band ratio */
9921 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9922 },
9923 { /* f857_1645[] */
9924 16415, /* A1 = 1.001953 */
9925 -23669, /* A2 = -0.722321 */
9926 -4549, /* B2 = -0.138847 */
9927 0, /* B1 = 0 */
9928 4549, /* B0 = 0.138847 */
9929 8456, /* A1 = 0.516174 */
9930 -28996, /* A2 = -0.884918 */
9931 13753, /* B2 = 0.419724 */
9932 -12, /* B1 = -0.000763 */
9933 13757, /* B0 = 0.419846 */
9934 24632, /* A1 = 1.503418 */
9935 -30271, /* A2 = -0.923828 */
9936 29070, /* B2 = 0.887146 */
9937 -25265, /* B1 = -1.542114 */
9938 29073, /* B0 = 0.887268 */
9939 7, /* Internal filter scaling */
9940 159, /* Minimum in-band energy threshold */
9941 21, /* 21/32 in-band to broad-band ratio */
9942 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9943 },
9944 { /* f900 */
9945 24806, /* A1 = -1.514099 */
9946 -32501, /* A2 = 0.991852 */
9947 -326, /* B2 = -0.009969 */
9948 0, /* B1 = 0.000000 */
9949 326, /* B0 = 0.009969 */
9950 24709, /* A1 = -1.508118 */
9951 -32659, /* A2 = 0.996674 */
9952 20277, /* B2 = 0.618835 */
9953 -15182, /* B1 = -0.926636 */
9954 20277, /* B0 = 0.618835 */
9955 25022, /* A1 = -1.527222 */
9956 -32661, /* A2 = 0.996735 */
9957 4320, /* B2 = 0.131836 */
9958 -3331, /* B1 = -0.203339 */
9959 4320, /* B0 = 0.131836 */
9960 5, /* Internal filter scaling */
9961 159, /* Minimum in-band energy threshold */
9962 21, /* 21/32 in-band to broad-band ratio */
9963 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9964 },
9965 { /* f900_1300[] */
9966 19776, /* A1 = 1.207092 */
9967 -27437, /* A2 = -0.837341 */
9968 -2666, /* B2 = -0.081371 */
9969 0, /* B1 = 0 */
9970 2666, /* B0 = 0.081371 */
9971 16302, /* A1 = 0.995026 */
9972 -30354, /* A2 = -0.926361 */
9973 10389, /* B2 = 0.317062 */
9974 -3327, /* B1 = -0.203064 */
9975 10389, /* B0 = 0.317062 */
9976 24299, /* A1 = 1.483154 */
9977 -30930, /* A2 = -0.943909 */
9978 25016, /* B2 = 0.763428 */
9979 -21171, /* B1 = -1.292236 */
9980 25016, /* B0 = 0.763428 */
9981 7, /* Internal filter scaling */
9982 159, /* Minimum in-band energy threshold */
9983 21, /* 21/32 in-band to broad-band ratio */
9984 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9985 },
9986 { /* f935_1215[] */
9987 20554, /* A1 = 1.254517 */
9988 -28764, /* A2 = -0.877838 */
9989 -2048, /* B2 = -0.062515 */
9990 0, /* B1 = 0 */
9991 2048, /* B0 = 0.062515 */
9992 18209, /* A1 = 1.11145 */
9993 -30951, /* A2 = -0.94458 */
9994 9390, /* B2 = 0.286575 */
9995 -3955, /* B1 = -0.241455 */
9996 9390, /* B0 = 0.286575 */
9997 23902, /* A1 = 1.458923 */
9998 -31286, /* A2 = -0.954803 */
9999 23252, /* B2 = 0.709595 */
10000 -19132, /* B1 = -1.167725 */
10001 23252, /* B0 = 0.709595 */
10002 7, /* Internal filter scaling */
10003 159, /* Minimum in-band energy threshold */
10004 21, /* 21/32 in-band to broad-band ratio */
10005 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10006 },
10007 { /* f941_1477[] */
10008 17543, /* A1 = 1.07074 */
10009 -26220, /* A2 = -0.800201 */
10010 -3298, /* B2 = -0.100647 */
10011 0, /* B1 = 0 */
10012 3298, /* B0 = 0.100647 */
10013 12423, /* A1 = 0.75827 */
10014 -30036, /* A2 = -0.916626 */
10015 12651, /* B2 = 0.386078 */
10016 -2444, /* B1 = -0.14917 */
10017 12653, /* B0 = 0.386154 */
10018 23518, /* A1 = 1.435425 */
10019 -30745, /* A2 = -0.938293 */
10020 27282, /* B2 = 0.832581 */
10021 -22529, /* B1 = -1.375122 */
10022 27286, /* B0 = 0.832703 */
10023 7, /* Internal filter scaling */
10024 159, /* Minimum in-band energy threshold */
10025 21, /* 21/32 in-band to broad-band ratio */
10026 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10027 },
10028 { /* f942 */
10029 24104, /* A1 = -1.471252 */
10030 -32507, /* A2 = 0.992065 */
10031 -351, /* B2 = -0.010722 */
10032 0, /* B1 = 0.000000 */
10033 351, /* B0 = 0.010722 */
10034 23996, /* A1 = -1.464600 */
10035 -32671, /* A2 = 0.997040 */
10036 22848, /* B2 = 0.697266 */
10037 -16639, /* B1 = -1.015564 */
10038 22848, /* B0 = 0.697266 */
10039 24332, /* A1 = -1.485168 */
10040 -32673, /* A2 = 0.997101 */
10041 4906, /* B2 = 0.149727 */
10042 -3672, /* B1 = -0.224174 */
10043 4906, /* B0 = 0.149727 */
10044 5, /* Internal filter scaling */
10045 159, /* Minimum in-band energy threshold */
10046 21, /* 21/32 in-band to broad-band ratio */
10047 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10048 },
10049 { /* f950 */
10050 23967, /* A1 = -1.462830 */
10051 -32507, /* A2 = 0.992065 */
10052 -518, /* B2 = -0.015821 */
10053 0, /* B1 = 0.000000 */
10054 518, /* B0 = 0.015821 */
10055 23856, /* A1 = -1.456055 */
10056 -32671, /* A2 = 0.997040 */
10057 26287, /* B2 = 0.802246 */
10058 -19031, /* B1 = -1.161560 */
10059 26287, /* B0 = 0.802246 */
10060 24195, /* A1 = -1.476746 */
10061 -32673, /* A2 = 0.997101 */
10062 2890, /* B2 = 0.088196 */
10063 -2151, /* B1 = -0.131317 */
10064 2890, /* B0 = 0.088196 */
10065 5, /* Internal filter scaling */
10066 159, /* Minimum in-band energy threshold */
10067 21, /* 21/32 in-band to broad-band ratio */
10068 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10069 },
10070 { /* f950_1400[] */
10071 18294, /* A1 = 1.116638 */
10072 -26962, /* A2 = -0.822845 */
10073 -2914, /* B2 = -0.088936 */
10074 0, /* B1 = 0 */
10075 2914, /* B0 = 0.088936 */
10076 14119, /* A1 = 0.861786 */
10077 -30227, /* A2 = -0.922455 */
10078 11466, /* B2 = 0.349945 */
10079 -2833, /* B1 = -0.172943 */
10080 11466, /* B0 = 0.349945 */
10081 23431, /* A1 = 1.430115 */
10082 -30828, /* A2 = -0.940796 */
10083 25331, /* B2 = 0.773071 */
10084 -20911, /* B1 = -1.276367 */
10085 25331, /* B0 = 0.773071 */
10086 7, /* Internal filter scaling */
10087 159, /* Minimum in-band energy threshold */
10088 21, /* 21/32 in-band to broad-band ratio */
10089 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10090 },
10091 { /* f975 */
10092 23521, /* A1 = -1.435608 */
10093 -32489, /* A2 = 0.991516 */
10094 -193, /* B2 = -0.005915 */
10095 0, /* B1 = 0.000000 */
10096 193, /* B0 = 0.005915 */
10097 23404, /* A1 = -1.428467 */
10098 -32655, /* A2 = 0.996582 */
10099 17740, /* B2 = 0.541412 */
10100 -12567, /* B1 = -0.767029 */
10101 17740, /* B0 = 0.541412 */
10102 23753, /* A1 = -1.449829 */
10103 -32657, /* A2 = 0.996613 */
10104 9090, /* B2 = 0.277405 */
10105 -6662, /* B1 = -0.406647 */
10106 9090, /* B0 = 0.277405 */
10107 5, /* Internal filter scaling */
10108 159, /* Minimum in-band energy threshold */
10109 21, /* 21/32 in-band to broad-band ratio */
10110 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10111 },
10112 { /* f1000 */
10113 23071, /* A1 = -1.408203 */
10114 -32489, /* A2 = 0.991516 */
10115 -293, /* B2 = -0.008965 */
10116 0, /* B1 = 0.000000 */
10117 293, /* B0 = 0.008965 */
10118 22951, /* A1 = -1.400818 */
10119 -32655, /* A2 = 0.996582 */
10120 5689, /* B2 = 0.173645 */
10121 -3951, /* B1 = -0.241150 */
10122 5689, /* B0 = 0.173645 */
10123 23307, /* A1 = -1.422607 */
10124 -32657, /* A2 = 0.996613 */
10125 18692, /* B2 = 0.570435 */
10126 -13447, /* B1 = -0.820770 */
10127 18692, /* B0 = 0.570435 */
10128 5, /* Internal filter scaling */
10129 159, /* Minimum in-band energy threshold */
10130 21, /* 21/32 in-band to broad-band ratio */
10131 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10132 },
10133 { /* f1020 */
10134 22701, /* A1 = -1.385620 */
10135 -32474, /* A2 = 0.991058 */
10136 -292, /* B2 = -0.008933 */
10137 0, /*163840 , B1 = 10.000000 */
10138 292, /* B0 = 0.008933 */
10139 22564, /* A1 = -1.377258 */
10140 -32655, /* A2 = 0.996552 */
10141 20756, /* B2 = 0.633423 */
10142 -14176, /* B1 = -0.865295 */
10143 20756, /* B0 = 0.633423 */
10144 22960, /* A1 = -1.401428 */
10145 -32657, /* A2 = 0.996613 */
10146 6520, /* B2 = 0.198990 */
10147 -4619, /* B1 = -0.281937 */
10148 6520, /* B0 = 0.198990 */
10149 5, /* Internal filter scaling */
10150 159, /* Minimum in-band energy threshold */
10151 21, /* 21/32 in-band to broad-band ratio */
10152 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10153 },
10154 { /* f1050 */
10155 22142, /* A1 = -1.351501 */
10156 -32474, /* A2 = 0.991058 */
10157 -147, /* B2 = -0.004493 */
10158 0, /* B1 = 0.000000 */
10159 147, /* B0 = 0.004493 */
10160 22000, /* A1 = -1.342834 */
10161 -32655, /* A2 = 0.996552 */
10162 15379, /* B2 = 0.469360 */
10163 -10237, /* B1 = -0.624847 */
10164 15379, /* B0 = 0.469360 */
10165 22406, /* A1 = -1.367554 */
10166 -32657, /* A2 = 0.996613 */
10167 17491, /* B2 = 0.533783 */
10168 -12096, /* B1 = -0.738312 */
10169 17491, /* B0 = 0.533783 */
10170 5, /* Internal filter scaling */
10171 159, /* Minimum in-band energy threshold */
10172 21, /* 21/32 in-band to broad-band ratio */
10173 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10174 },
10175 { /* f1100_1750[] */
10176 12973, /* A1 = 0.79184 */
10177 -24916, /* A2 = -0.760376 */
10178 6655, /* B2 = 0.203102 */
10179 367, /* B1 = 0.0224 */
10180 6657, /* B0 = 0.203171 */
10181 5915, /* A1 = 0.361053 */
10182 -29560, /* A2 = -0.90213 */
10183 -7777, /* B2 = -0.23735 */
10184 0, /* B1 = 0 */
10185 7777, /* B0 = 0.23735 */
10186 20510, /* A1 = 1.251892 */
10187 -30260, /* A2 = -0.923462 */
10188 26662, /* B2 = 0.81366 */
10189 -20573, /* B1 = -1.255737 */
10190 26668, /* B0 = 0.813843 */
10191 7, /* Internal filter scaling */
10192 159, /* Minimum in-band energy threshold */
10193 21, /* 21/32 in-band to broad-band ratio */
10194 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10195 },
10196 { /* f1140 */
10197 20392, /* A1 = -1.244629 */
10198 -32460, /* A2 = 0.990601 */
10199 -270, /* B2 = -0.008240 */
10200 0, /* B1 = 0.000000 */
10201 270, /* B0 = 0.008240 */
10202 20218, /* A1 = -1.234009 */
10203 -32655, /* A2 = 0.996582 */
10204 21337, /* B2 = 0.651154 */
10205 -13044, /* B1 = -0.796143 */
10206 21337, /* B0 = 0.651154 */
10207 20684, /* A1 = -1.262512 */
10208 -32657, /* A2 = 0.996643 */
10209 8572, /* B2 = 0.261612 */
10210 -5476, /* B1 = -0.334244 */
10211 8572, /* B0 = 0.261612 */
10212 5, /* Internal filter scaling */
10213 159, /* Minimum in-band energy threshold */
10214 21, /* 21/32 in-band to broad-band ratio */
10215 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10216 },
10217 { /* f1200 */
10218 19159, /* A1 = -1.169373 */
10219 -32456, /* A2 = 0.990509 */
10220 -335, /* B2 = -0.010252 */
10221 0, /* B1 = 0.000000 */
10222 335, /* B0 = 0.010252 */
10223 18966, /* A1 = -1.157593 */
10224 -32661, /* A2 = 0.996735 */
10225 6802, /* B2 = 0.207588 */
10226 -3900, /* B1 = -0.238098 */
10227 6802, /* B0 = 0.207588 */
10228 19467, /* A1 = -1.188232 */
10229 -32661, /* A2 = 0.996765 */
10230 25035, /* B2 = 0.764008 */
10231 -15049, /* B1 = -0.918579 */
10232 25035, /* B0 = 0.764008 */
10233 5, /* Internal filter scaling */
10234 159, /* Minimum in-band energy threshold */
10235 21, /* 21/32 in-band to broad-band ratio */
10236 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10237 },
10238 { /* f1209 */
10239 18976, /* A1 = -1.158264 */
10240 -32439, /* A2 = 0.989990 */
10241 -183, /* B2 = -0.005588 */
10242 0, /* B1 = 0.000000 */
10243 183, /* B0 = 0.005588 */
10244 18774, /* A1 = -1.145874 */
10245 -32650, /* A2 = 0.996429 */
10246 15468, /* B2 = 0.472076 */
10247 -8768, /* B1 = -0.535217 */
10248 15468, /* B0 = 0.472076 */
10249 19300, /* A1 = -1.177979 */
10250 -32652, /* A2 = 0.996490 */
10251 19840, /* B2 = 0.605499 */
10252 -11842, /* B1 = -0.722809 */
10253 19840, /* B0 = 0.605499 */
10254 5, /* Internal filter scaling */
10255 159, /* Minimum in-band energy threshold */
10256 21, /* 21/32 in-band to broad-band ratio */
10257 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10258 },
10259 { /* f1330 */
10260 16357, /* A1 = -0.998413 */
10261 -32368, /* A2 = 0.987793 */
10262 -217, /* B2 = -0.006652 */
10263 0, /* B1 = 0.000000 */
10264 217, /* B0 = 0.006652 */
10265 16107, /* A1 = -0.983126 */
10266 -32601, /* A2 = 0.994904 */
10267 11602, /* B2 = 0.354065 */
10268 -5555, /* B1 = -0.339111 */
10269 11602, /* B0 = 0.354065 */
10270 16722, /* A1 = -1.020630 */
10271 -32603, /* A2 = 0.994965 */
10272 15574, /* B2 = 0.475311 */
10273 -8176, /* B1 = -0.499069 */
10274 15574, /* B0 = 0.475311 */
10275 5, /* Internal filter scaling */
10276 159, /* Minimum in-band energy threshold */
10277 21, /* 21/32 in-band to broad-band ratio */
10278 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10279 },
10280 { /* f1336 */
10281 16234, /* A1 = -0.990875 */
10282 32404, /* A2 = -0.988922 */
10283 -193, /* B2 = -0.005908 */
10284 0, /* B1 = 0.000000 */
10285 193, /* B0 = 0.005908 */
10286 15986, /* A1 = -0.975769 */
10287 -32632, /* A2 = 0.995880 */
10288 18051, /* B2 = 0.550903 */
10289 -8658, /* B1 = -0.528473 */
10290 18051, /* B0 = 0.550903 */
10291 16591, /* A1 = -1.012695 */
10292 -32634, /* A2 = 0.995941 */
10293 15736, /* B2 = 0.480240 */
10294 -8125, /* B1 = -0.495926 */
10295 15736, /* B0 = 0.480240 */
10296 5, /* Internal filter scaling */
10297 159, /* Minimum in-band energy threshold */
10298 21, /* 21/32 in-band to broad-band ratio */
10299 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10300 },
10301 { /* f1366 */
10302 15564, /* A1 = -0.949982 */
10303 -32404, /* A2 = 0.988922 */
10304 -269, /* B2 = -0.008216 */
10305 0, /* B1 = 0.000000 */
10306 269, /* B0 = 0.008216 */
10307 15310, /* A1 = -0.934479 */
10308 -32632, /* A2 = 0.995880 */
10309 10815, /* B2 = 0.330063 */
10310 -4962, /* B1 = -0.302887 */
10311 10815, /* B0 = 0.330063 */
10312 15924, /* A1 = -0.971924 */
10313 -32634, /* A2 = 0.995941 */
10314 18880, /* B2 = 0.576172 */
10315 -9364, /* B1 = -0.571594 */
10316 18880, /* B0 = 0.576172 */
10317 5, /* Internal filter scaling */
10318 159, /* Minimum in-band energy threshold */
10319 21, /* 21/32 in-band to broad-band ratio */
10320 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10321 },
10322 { /* f1380 */
10323 15247, /* A1 = -0.930603 */
10324 -32397, /* A2 = 0.988708 */
10325 -244, /* B2 = -0.007451 */
10326 0, /* B1 = 0.000000 */
10327 244, /* B0 = 0.007451 */
10328 14989, /* A1 = -0.914886 */
10329 -32627, /* A2 = 0.995697 */
10330 18961, /* B2 = 0.578644 */
10331 -8498, /* B1 = -0.518707 */
10332 18961, /* B0 = 0.578644 */
10333 15608, /* A1 = -0.952667 */
10334 -32628, /* A2 = 0.995758 */
10335 11145, /* B2 = 0.340134 */
10336 -5430, /* B1 = -0.331467 */
10337 11145, /* B0 = 0.340134 */
10338 5, /* Internal filter scaling */
10339 159, /* Minimum in-band energy threshold */
10340 21, /* 21/32 in-band to broad-band ratio */
10341 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10342 },
10343 { /* f1400 */
10344 14780, /* A1 = -0.902130 */
10345 -32393, /* A2 = 0.988586 */
10346 -396, /* B2 = -0.012086 */
10347 0, /* B1 = 0.000000 */
10348 396, /* B0 = 0.012086 */
10349 14510, /* A1 = -0.885651 */
10350 -32630, /* A2 = 0.995819 */
10351 6326, /* B2 = 0.193069 */
10352 -2747, /* B1 = -0.167671 */
10353 6326, /* B0 = 0.193069 */
10354 15154, /* A1 = -0.924957 */
10355 -32632, /* A2 = 0.995850 */
10356 23235, /* B2 = 0.709076 */
10357 -10983, /* B1 = -0.670380 */
10358 23235, /* B0 = 0.709076 */
10359 5, /* Internal filter scaling */
10360 159, /* Minimum in-band energy threshold */
10361 21, /* 21/32 in-band to broad-band ratio */
10362 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10363 },
10364 { /* f1477 */
10365 13005, /* A1 = -0.793793 */
10366 -32368, /* A2 = 0.987823 */
10367 -500, /* B2 = -0.015265 */
10368 0, /* B1 = 0.000000 */
10369 500, /* B0 = 0.015265 */
10370 12708, /* A1 = -0.775665 */
10371 -32615, /* A2 = 0.995331 */
10372 11420, /* B2 = 0.348526 */
10373 -4306, /* B1 = -0.262833 */
10374 11420, /* B0 = 0.348526 */
10375 13397, /* A1 = -0.817688 */
10376 -32615, /* A2 = 0.995361 */
10377 9454, /* B2 = 0.288528 */
10378 -3981, /* B1 = -0.243027 */
10379 9454, /* B0 = 0.288528 */
10380 5, /* Internal filter scaling */
10381 159, /* Minimum in-band energy threshold */
10382 21, /* 21/32 in-band to broad-band ratio */
10383 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10384 },
10385 { /* f1600 */
10386 10046, /* A1 = -0.613190 */
10387 -32331, /* A2 = 0.986694 */
10388 -455, /* B2 = -0.013915 */
10389 0, /* B1 = 0.000000 */
10390 455, /* B0 = 0.013915 */
10391 9694, /* A1 = -0.591705 */
10392 -32601, /* A2 = 0.994934 */
10393 6023, /* B2 = 0.183815 */
10394 -1708, /* B1 = -0.104279 */
10395 6023, /* B0 = 0.183815 */
10396 10478, /* A1 = -0.639587 */
10397 -32603, /* A2 = 0.994965 */
10398 22031, /* B2 = 0.672333 */
10399 -7342, /* B1 = -0.448151 */
10400 22031, /* B0 = 0.672333 */
10401 5, /* Internal filter scaling */
10402 159, /* Minimum in-band energy threshold */
10403 21, /* 21/32 in-band to broad-band ratio */
10404 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10405 },
10406 { /* f1633_1638[] */
10407 9181, /* A1 = 0.560394 */
10408 -32256, /* A2 = -0.984375 */
10409 -556, /* B2 = -0.016975 */
10410 0, /* B1 = 0 */
10411 556, /* B0 = 0.016975 */
10412 8757, /* A1 = 0.534515 */
10413 -32574, /* A2 = -0.99408 */
10414 8443, /* B2 = 0.25769 */
10415 -2135, /* B1 = -0.130341 */
10416 8443, /* B0 = 0.25769 */
10417 9691, /* A1 = 0.591522 */
10418 -32574, /* A2 = -0.99411 */
10419 15446, /* B2 = 0.471375 */
10420 -4809, /* B1 = -0.293579 */
10421 15446, /* B0 = 0.471375 */
10422 7, /* Internal filter scaling */
10423 159, /* Minimum in-band energy threshold */
10424 21, /* 21/32 in-band to broad-band ratio */
10425 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10426 },
10427 { /* f1800 */
10428 5076, /* A1 = -0.309875 */
10429 -32304, /* A2 = 0.985840 */
10430 -508, /* B2 = -0.015503 */
10431 0, /* B1 = 0.000000 */
10432 508, /* B0 = 0.015503 */
10433 4646, /* A1 = -0.283600 */
10434 -32605, /* A2 = 0.995026 */
10435 6742, /* B2 = 0.205780 */
10436 -878, /* B1 = -0.053635 */
10437 6742, /* B0 = 0.205780 */
10438 5552, /* A1 = -0.338928 */
10439 -32605, /* A2 = 0.995056 */
10440 23667, /* B2 = 0.722260 */
10441 -4297, /* B1 = -0.262329 */
10442 23667, /* B0 = 0.722260 */
10443 5, /* Internal filter scaling */
10444 159, /* Minimum in-band energy threshold */
10445 21, /* 21/32 in-band to broad-band ratio */
10446 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10447 },
10448 { /* f1860 */
10449 3569, /* A1 = -0.217865 */
10450 -32292, /* A2 = 0.985504 */
10451 -239, /* B2 = -0.007322 */
10452 0, /* B1 = 0.000000 */
10453 239, /* B0 = 0.007322 */
10454 3117, /* A1 = -0.190277 */
10455 -32603, /* A2 = 0.994965 */
10456 18658, /* B2 = 0.569427 */
10457 -1557, /* B1 = -0.095032 */
10458 18658, /* B0 = 0.569427 */
10459 4054, /* A1 = -0.247437 */
10460 -32603, /* A2 = 0.994965 */
10461 18886, /* B2 = 0.576385 */
10462 -2566, /* B1 = -0.156647 */
10463 18886, /* B0 = 0.576385 */
10464 5, /* Internal filter scaling */
10465 159, /* Minimum in-band energy threshold */
10466 21, /* 21/32 in-band to broad-band ratio */
10467 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10468 },
10469 };
10470 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10471 {
10472 unsigned short cmd;
10473 int cnt, max;
10474
10475 if (jf->filter > 3) {
10476 return -1;
10477 }
10478 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10479
10480 return -1;
10481 if (!jf->enable) {
10482 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10483
10484 return -1;
10485 else
10486 return 0;
10487 } else {
10488 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10489
10490 return -1;
10491 /* Select the filter (f0 - f3) to use. */
10492 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10493 return -1;
10494 }
10495 if (jf->freq < 12 && jf->freq > 3) {
10496 /* Select the frequency for the selected filter. */
10497 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10498 return -1;
10499 } else if (jf->freq > 11) {
10500 /* We need to load a programmable filter set for undefined */
10501 /* frequencies. So we will point the filter to a programmable set. */
10502 /* Since there are only 4 filters and 4 programmable sets, we will */
10503 /* just point the filter to the same number set and program it for the */
10504 /* frequency we want. */
10505 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10506 return -1;
10507 if (j->ver.low != 0x12) {
10508 cmd = 0x515B;
10509 max = 19;
10510 } else {
10511 cmd = 0x515E;
10512 max = 15;
10513 }
10514 if (ixj_WriteDSPCommand(cmd, j))
10515 return -1;
10516 for (cnt = 0; cnt < max; cnt++) {
10517 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10518 return -1;
10519 }
10520 }
10521 j->filter_en[jf->filter] = jf->enable;
10522 return 0;
10523 }
10524
10525 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10526 {
10527 unsigned short cmd;
10528 int cnt, max;
10529 if (jfr->filter > 3) {
10530 return -1;
10531 }
10532 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10533 return -1;
10534
10535 if (!jfr->enable) {
10536 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10537 return -1;
10538 else
10539 return 0;
10540 } else {
10541 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10542 return -1;
10543 /* Select the filter (f0 - f3) to use. */
10544 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10545 return -1;
10546 }
10547 /* We need to load a programmable filter set for undefined */
10548 /* frequencies. So we will point the filter to a programmable set. */
10549 /* Since there are only 4 filters and 4 programmable sets, we will */
10550 /* just point the filter to the same number set and program it for the */
10551 /* frequency we want. */
10552 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10553 return -1;
10554 if (j->ver.low != 0x12) {
10555 cmd = 0x515B;
10556 max = 19;
10557 } else {
10558 cmd = 0x515E;
10559 max = 15;
10560 }
10561 if (ixj_WriteDSPCommand(cmd, j))
10562 return -1;
10563 for (cnt = 0; cnt < max; cnt++) {
10564 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10565 return -1;
10566 }
10567 j->filter_en[jfr->filter] = jfr->enable;
10568 return 0;
10569 }
10570
10571 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10572 {
10573 int freq0, freq1;
10574 unsigned short data;
10575 if (ti->freq0) {
10576 freq0 = ti->freq0;
10577 } else {
10578 freq0 = 0x7FFF;
10579 }
10580
10581 if (ti->freq1) {
10582 freq1 = ti->freq1;
10583 } else {
10584 freq1 = 0x7FFF;
10585 }
10586
10587 if(ti->tone_index > 12 && ti->tone_index < 28)
10588 {
10589 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10590 return -1;
10591 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10592 return -1;
10593 data = freq0;
10594 if (ixj_WriteDSPCommand(data, j))
10595 return -1;
10596 data = freq1;
10597 if (ixj_WriteDSPCommand(data, j))
10598 return -1;
10599 }
10600 return freq0;
10601 }
10602
Ubuntu Artful kernel mirror