?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / telephony / ixj.c
blob59a6515e760f5d4041c18f18deb7a70ee7117afa
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_PARM(ixjdebug, "i");
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_DownloadG729 = &Stub;
410 static IXJ_REGFUNC ixj_DownloadTS85 = &Stub;
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415 static IXJ_REGFUNC ixj_PreIoctl = &Stub;
416 static IXJ_REGFUNC ixj_PostIoctl = &Stub;
417
418 static void ixj_read_frame(IXJ *j);
419 static void ixj_write_frame(IXJ *j);
420 static void ixj_init_timer(IXJ *j);
421 static void ixj_add_timer(IXJ * j);
422 static void ixj_timeout(unsigned long ptr);
423 static int read_filters(IXJ *j);
424 static int LineMonitor(IXJ *j);
425 static int ixj_fasync(int fd, struct file *, int mode);
426 static int ixj_set_port(IXJ *j, int arg);
427 static int ixj_set_pots(IXJ *j, int arg);
428 static int ixj_hookstate(IXJ *j);
429 static int ixj_record_start(IXJ *j);
430 static void ixj_record_stop(IXJ *j);
431 static void set_rec_volume(IXJ *j, int volume);
432 static int get_rec_volume(IXJ *j);
433 static int set_rec_codec(IXJ *j, int rate);
434 static void ixj_vad(IXJ *j, int arg);
435 static int ixj_play_start(IXJ *j);
436 static void ixj_play_stop(IXJ *j);
437 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
438 static int ixj_set_tone_off(unsigned short, IXJ *j);
439 static int ixj_play_tone(IXJ *j, char tone);
440 static void ixj_aec_start(IXJ *j, int level);
441 static int idle(IXJ *j);
442 static void ixj_ring_on(IXJ *j);
443 static void ixj_ring_off(IXJ *j);
444 static void aec_stop(IXJ *j);
445 static void ixj_ringback(IXJ *j);
446 static void ixj_busytone(IXJ *j);
447 static void ixj_dialtone(IXJ *j);
448 static void ixj_cpt_stop(IXJ *j);
449 static char daa_int_read(IXJ *j);
450 static char daa_CR_read(IXJ *j, int cr);
451 static int daa_set_mode(IXJ *j, int mode);
452 static int ixj_linetest(IXJ *j);
453 static int ixj_daa_write(IXJ *j);
454 static int ixj_daa_cid_read(IXJ *j);
455 static void DAA_Coeff_US(IXJ *j);
456 static void DAA_Coeff_UK(IXJ *j);
457 static void DAA_Coeff_France(IXJ *j);
458 static void DAA_Coeff_Germany(IXJ *j);
459 static void DAA_Coeff_Australia(IXJ *j);
460 static void DAA_Coeff_Japan(IXJ *j);
461 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
462 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
463 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
464 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
465 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
466 /* Serial Control Interface funtions */
467 static int SCI_Control(IXJ *j, int control);
468 static int SCI_Prepare(IXJ *j);
469 static int SCI_WaitHighSCI(IXJ *j);
470 static int SCI_WaitLowSCI(IXJ *j);
471 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
472 static int ixj_PCcontrol_wait(IXJ *j);
473 static void ixj_pre_cid(IXJ *j);
474 static void ixj_write_cid(IXJ *j);
475 static void ixj_write_cid_bit(IXJ *j, int bit);
476 static int set_base_frame(IXJ *j, int size);
477 static int set_play_codec(IXJ *j, int rate);
478 static void set_rec_depth(IXJ *j, int depth);
479 static int ixj_mixer(long val, IXJ *j);
480
481 /************************************************************************
482 CT8020/CT8021 Host Programmers Model
483 Host address Function Access
484 DSPbase +
485 0-1 Aux Software Status Register (reserved) Read Only
486 2-3 Software Status Register Read Only
487 4-5 Aux Software Control Register (reserved) Read Write
488 6-7 Software Control Register Read Write
489 8-9 Hardware Status Register Read Only
490 A-B Hardware Control Register Read Write
491 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
492 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
493 ************************************************************************/
494
495 static inline void ixj_read_HSR(IXJ *j)
496 {
497 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
498 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
499 }
500
501 static inline int IsControlReady(IXJ *j)
502 {
503 ixj_read_HSR(j);
504 return j->hsr.bits.controlrdy ? 1 : 0;
505 }
506
507 static inline int IsPCControlReady(IXJ *j)
508 {
509 j->pccr1.byte = inb_p(j->XILINXbase + 3);
510 return j->pccr1.bits.crr ? 1 : 0;
511 }
512
513 static inline int IsStatusReady(IXJ *j)
514 {
515 ixj_read_HSR(j);
516 return j->hsr.bits.statusrdy ? 1 : 0;
517 }
518
519 static inline int IsRxReady(IXJ *j)
520 {
521 ixj_read_HSR(j);
522 ixj_perfmon(j->rxreadycheck);
523 return j->hsr.bits.rxrdy ? 1 : 0;
524 }
525
526 static inline int IsTxReady(IXJ *j)
527 {
528 ixj_read_HSR(j);
529 ixj_perfmon(j->txreadycheck);
530 return j->hsr.bits.txrdy ? 1 : 0;
531 }
532
533 static inline void set_play_volume(IXJ *j, int volume)
534 {
535 if (ixjdebug & 0x0002)
536 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
537 ixj_WriteDSPCommand(0xCF02, j);
538 ixj_WriteDSPCommand(volume, j);
539 }
540
541 static int set_play_volume_linear(IXJ *j, int volume)
542 {
543 int newvolume, dspplaymax;
544
545 if (ixjdebug & 0x0002)
546 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
547 if(volume > 100 || volume < 0) {
548 return -1;
549 }
550
551 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
552 switch (j->cardtype) {
553 case QTI_PHONEJACK:
554 dspplaymax = 0x380;
555 break;
556 case QTI_LINEJACK:
557 if(j->port == PORT_PSTN) {
558 dspplaymax = 0x48;
559 } else {
560 dspplaymax = 0x100;
561 }
562 break;
563 case QTI_PHONEJACK_LITE:
564 dspplaymax = 0x380;
565 break;
566 case QTI_PHONEJACK_PCI:
567 dspplaymax = 0x6C;
568 break;
569 case QTI_PHONECARD:
570 dspplaymax = 0x50;
571 break;
572 default:
573 return -1;
574 }
575 newvolume = (dspplaymax * volume) / 100;
576 set_play_volume(j, newvolume);
577 return 0;
578 }
579
580 static inline void set_play_depth(IXJ *j, int depth)
581 {
582 if (depth > 60)
583 depth = 60;
584 if (depth < 0)
585 depth = 0;
586 ixj_WriteDSPCommand(0x5280 + depth, j);
587 }
588
589 static inline int get_play_volume(IXJ *j)
590 {
591 ixj_WriteDSPCommand(0xCF00, j);
592 return j->ssr.high << 8 | j->ssr.low;
593 }
594
595 static int get_play_volume_linear(IXJ *j)
596 {
597 int volume, newvolume, dspplaymax;
598
599 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
600 switch (j->cardtype) {
601 case QTI_PHONEJACK:
602 dspplaymax = 0x380;
603 break;
604 case QTI_LINEJACK:
605 if(j->port == PORT_PSTN) {
606 dspplaymax = 0x48;
607 } else {
608 dspplaymax = 0x100;
609 }
610 break;
611 case QTI_PHONEJACK_LITE:
612 dspplaymax = 0x380;
613 break;
614 case QTI_PHONEJACK_PCI:
615 dspplaymax = 0x6C;
616 break;
617 case QTI_PHONECARD:
618 dspplaymax = 100;
619 break;
620 default:
621 return -1;
622 }
623 volume = get_play_volume(j);
624 newvolume = (volume * 100) / dspplaymax;
625 if(newvolume > 100)
626 newvolume = 100;
627 return newvolume;
628 }
629
630 static inline BYTE SLIC_GetState(IXJ *j)
631 {
632 if (j->cardtype == QTI_PHONECARD) {
633 j->pccr1.byte = 0;
634 j->psccr.bits.dev = 3;
635 j->psccr.bits.rw = 1;
636 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
637 ixj_PCcontrol_wait(j);
638 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
639 ixj_PCcontrol_wait(j);
640 if (j->pslic.bits.powerdown)
641 return PLD_SLIC_STATE_OC;
642 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
643 return PLD_SLIC_STATE_ACTIVE;
644 else
645 return PLD_SLIC_STATE_RINGING;
646 } else {
647 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
648 }
649 return j->pld_slicr.bits.state;
650 }
651
652 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
653 {
654 BOOL fRetVal = FALSE;
655
656 if (j->cardtype == QTI_PHONECARD) {
657 if (j->flags.pcmciasct) {
658 switch (byState) {
659 case PLD_SLIC_STATE_TIPOPEN:
660 case PLD_SLIC_STATE_OC:
661 j->pslic.bits.powerdown = 1;
662 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
663 fRetVal = TRUE;
664 break;
665 case PLD_SLIC_STATE_RINGING:
666 if (j->readers || j->writers) {
667 j->pslic.bits.powerdown = 0;
668 j->pslic.bits.ring0 = 1;
669 j->pslic.bits.ring1 = 0;
670 fRetVal = TRUE;
671 }
672 break;
673 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
674
675 case PLD_SLIC_STATE_STANDBY:
676 case PLD_SLIC_STATE_ACTIVE:
677 if (j->readers || j->writers) {
678 j->pslic.bits.powerdown = 0;
679 } else {
680 j->pslic.bits.powerdown = 1;
681 }
682 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
683 fRetVal = TRUE;
684 break;
685 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
686
687 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
688
689 default:
690 fRetVal = FALSE;
691 break;
692 }
693 j->psccr.bits.dev = 3;
694 j->psccr.bits.rw = 0;
695 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
696 ixj_PCcontrol_wait(j);
697 }
698 } else {
699 /* Set the C1, C2, C3 & B2EN signals. */
700 switch (byState) {
701 case PLD_SLIC_STATE_OC:
702 j->pld_slicw.bits.c1 = 0;
703 j->pld_slicw.bits.c2 = 0;
704 j->pld_slicw.bits.c3 = 0;
705 j->pld_slicw.bits.b2en = 0;
706 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
707 fRetVal = TRUE;
708 break;
709 case PLD_SLIC_STATE_RINGING:
710 j->pld_slicw.bits.c1 = 1;
711 j->pld_slicw.bits.c2 = 0;
712 j->pld_slicw.bits.c3 = 0;
713 j->pld_slicw.bits.b2en = 1;
714 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
715 fRetVal = TRUE;
716 break;
717 case PLD_SLIC_STATE_ACTIVE:
718 j->pld_slicw.bits.c1 = 0;
719 j->pld_slicw.bits.c2 = 1;
720 j->pld_slicw.bits.c3 = 0;
721 j->pld_slicw.bits.b2en = 0;
722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
723 fRetVal = TRUE;
724 break;
725 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
726
727 j->pld_slicw.bits.c1 = 1;
728 j->pld_slicw.bits.c2 = 1;
729 j->pld_slicw.bits.c3 = 0;
730 j->pld_slicw.bits.b2en = 0;
731 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
732 fRetVal = TRUE;
733 break;
734 case PLD_SLIC_STATE_TIPOPEN:
735 j->pld_slicw.bits.c1 = 0;
736 j->pld_slicw.bits.c2 = 0;
737 j->pld_slicw.bits.c3 = 1;
738 j->pld_slicw.bits.b2en = 0;
739 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
740 fRetVal = TRUE;
741 break;
742 case PLD_SLIC_STATE_STANDBY:
743 j->pld_slicw.bits.c1 = 1;
744 j->pld_slicw.bits.c2 = 0;
745 j->pld_slicw.bits.c3 = 1;
746 j->pld_slicw.bits.b2en = 1;
747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
748 fRetVal = TRUE;
749 break;
750 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
751
752 j->pld_slicw.bits.c1 = 0;
753 j->pld_slicw.bits.c2 = 1;
754 j->pld_slicw.bits.c3 = 1;
755 j->pld_slicw.bits.b2en = 0;
756 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
757 fRetVal = TRUE;
758 break;
759 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
760
761 j->pld_slicw.bits.c1 = 1;
762 j->pld_slicw.bits.c2 = 1;
763 j->pld_slicw.bits.c3 = 1;
764 j->pld_slicw.bits.b2en = 0;
765 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
766 fRetVal = TRUE;
767 break;
768 default:
769 fRetVal = FALSE;
770 break;
771 }
772 }
773
774 return fRetVal;
775 }
776
777 static int ixj_wink(IXJ *j)
778 {
779 BYTE slicnow;
780
781 slicnow = SLIC_GetState(j);
782
783 j->pots_winkstart = jiffies;
784 SLIC_SetState(PLD_SLIC_STATE_OC, j);
785
786 while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
787 set_current_state(TASK_INTERRUPTIBLE);
788 schedule_timeout(1);
789 }
790
791 SLIC_SetState(slicnow, j);
792 return 0;
793 }
794
795 static int ixj_register(int index, IXJ_REGFUNC regfunc)
796 {
797 int cnt;
798 int retval = 0;
799 switch (index) {
800 case G729LOADER:
801 ixj_DownloadG729 = regfunc;
802 for (cnt = 0; cnt < IXJMAX; cnt++) {
803 IXJ *j = get_ixj(cnt);
804 while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
805 set_current_state(TASK_INTERRUPTIBLE);
806 schedule_timeout(1);
807 }
808 ixj_DownloadG729(j, 0L);
809 clear_bit(cnt, &j->busyflags);
810 }
811 break;
812 case TS85LOADER:
813 ixj_DownloadTS85 = regfunc;
814 for (cnt = 0; cnt < IXJMAX; cnt++) {
815 IXJ *j = get_ixj(cnt);
816 while(test_and_set_bit(cnt, (void *)&j->busyflags) != 0) {
817 set_current_state(TASK_INTERRUPTIBLE);
818 schedule_timeout(1);
819 }
820 ixj_DownloadTS85(j, 0L);
821 clear_bit(cnt, &j->busyflags);
822 }
823 break;
824 case PRE_READ:
825 ixj_PreRead = regfunc;
826 break;
827 case POST_READ:
828 ixj_PostRead = regfunc;
829 break;
830 case PRE_WRITE:
831 ixj_PreWrite = regfunc;
832 break;
833 case POST_WRITE:
834 ixj_PostWrite = regfunc;
835 break;
836 case PRE_IOCTL:
837 ixj_PreIoctl = regfunc;
838 break;
839 case POST_IOCTL:
840 ixj_PostIoctl = regfunc;
841 break;
842 default:
843 retval = 1;
844 }
845 return retval;
846 }
847
848 EXPORT_SYMBOL(ixj_register);
849
850 static int ixj_unregister(int index)
851 {
852 int retval = 0;
853 switch (index) {
854 case G729LOADER:
855 ixj_DownloadG729 = &Stub;
856 break;
857 case TS85LOADER:
858 ixj_DownloadTS85 = &Stub;
859 break;
860 case PRE_READ:
861 ixj_PreRead = &Stub;
862 break;
863 case POST_READ:
864 ixj_PostRead = &Stub;
865 break;
866 case PRE_WRITE:
867 ixj_PreWrite = &Stub;
868 break;
869 case POST_WRITE:
870 ixj_PostWrite = &Stub;
871 break;
872 case PRE_IOCTL:
873 ixj_PreIoctl = &Stub;
874 break;
875 case POST_IOCTL:
876 ixj_PostIoctl = &Stub;
877 break;
878 default:
879 retval = 1;
880 }
881 return retval;
882 }
883
884 EXPORT_SYMBOL(ixj_unregister);
885
886 static void ixj_init_timer(IXJ *j)
887 {
888 init_timer(&j->timer);
889 j->timer.function = ixj_timeout;
890 j->timer.data = (unsigned long)j;
891 }
892
893 static void ixj_add_timer(IXJ *j)
894 {
895 j->timer.expires = jiffies + (hertz / samplerate);
896 add_timer(&j->timer);
897 }
898
899 static void ixj_tone_timeout(IXJ *j)
900 {
901 IXJ_TONE ti;
902
903 j->tone_state++;
904 if (j->tone_state == 3) {
905 j->tone_state = 0;
906 if (j->cadence_t) {
907 j->tone_cadence_state++;
908 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
909 switch (j->cadence_t->termination) {
910 case PLAY_ONCE:
911 ixj_cpt_stop(j);
912 break;
913 case REPEAT_LAST_ELEMENT:
914 j->tone_cadence_state--;
915 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
916 break;
917 case REPEAT_ALL:
918 j->tone_cadence_state = 0;
919 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
920 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
921 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
922 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
923 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
924 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
925 ixj_init_tone(j, &ti);
926 }
927 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
928 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
929 ixj_play_tone(j, j->cadence_t->ce[0].index);
930 break;
931 }
932 } else {
933 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
934 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
935 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
936 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
937 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
938 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
939 ixj_init_tone(j, &ti);
940 }
941 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
942 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
943 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
944 }
945 }
946 }
947 }
948
949 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
950 {
951 if(j->ixj_signals[event]) {
952 if(ixjdebug & 0x0100)
953 printk("Sending signal for event %d\n", event);
954 /* Send apps notice of change */
955 /* see config.h for macro definition */
956 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
957 }
958 }
959
960 static void ixj_pstn_state(IXJ *j)
961 {
962 int var;
963 union XOPXR0 XR0, daaint;
964
965 var = 10;
966
967 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
968 daaint.reg = 0;
969 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
970
971 j->pld_scrr.byte = inb_p(j->XILINXbase);
972 if (j->pld_scrr.bits.daaflag) {
973 daa_int_read(j);
974 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
975 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
976 daaint.bitreg.RING = 1;
977 if(ixjdebug & 0x0008) {
978 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
979 }
980 } else {
981 daa_set_mode(j, SOP_PU_RESET);
982 }
983 }
984 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
985 daaint.bitreg.Caller_ID = 1;
986 j->pstn_cid_intr = 1;
987 j->pstn_cid_received = jiffies;
988 if(ixjdebug & 0x0008) {
989 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
990 }
991 }
992 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
993 daaint.bitreg.Cadence = 1;
994 if(ixjdebug & 0x0008) {
995 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
996 }
997 }
998 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
999 daaint.bitreg.VDD_OK = 1;
1000 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
1001 }
1002 }
1003 daa_CR_read(j, 1);
1004 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)) {
1005 daaint.bitreg.RMR = 1;
1006 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
1007 if(ixjdebug & 0x0008) {
1008 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);
1009 }
1010 j->pstn_prev_rmr = j->pstn_last_rmr;
1011 j->pstn_last_rmr = jiffies;
1012 }
1013 switch(j->daa_mode) {
1014 case SOP_PU_SLEEP:
1015 if (daaint.bitreg.RING) {
1016 if (!j->flags.pstn_ringing) {
1017 if (j->daa_mode != SOP_PU_RINGING) {
1018 j->pstn_ring_int = jiffies;
1019 daa_set_mode(j, SOP_PU_RINGING);
1020 }
1021 }
1022 }
1023 break;
1024 case SOP_PU_RINGING:
1025 if (daaint.bitreg.RMR) {
1026 if (ixjdebug & 0x0008) {
1027 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1028 }
1029 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
1030 j->flags.pstn_rmr = 1;
1031 j->pstn_ring_start = jiffies;
1032 j->pstn_ring_stop = 0;
1033 j->ex.bits.pstn_ring = 0;
1034 if (j->cadence_f[4].state == 0) {
1035 j->cadence_f[4].state = 1;
1036 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
1037 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
1038 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
1039 } else if (j->cadence_f[4].state == 2) {
1040 if((time_after(jiffies, j->cadence_f[4].off1min) &&
1041 time_before(jiffies, j->cadence_f[4].off1max))) {
1042 if (j->cadence_f[4].on2) {
1043 j->cadence_f[4].state = 3;
1044 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 if (ixjdebug & 0x0008) {
1052 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1053 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1054 j->cadence_f[4].off1);
1055 }
1056 j->cadence_f[4].state = 0;
1057 }
1058 } else if (j->cadence_f[4].state == 4) {
1059 if((time_after(jiffies, j->cadence_f[4].off2min) &&
1060 time_before(jiffies, j->cadence_f[4].off2max))) {
1061 if (j->cadence_f[4].on3) {
1062 j->cadence_f[4].state = 5;
1063 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
1064 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
1065 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
1066 } else {
1067 j->cadence_f[4].state = 7;
1068 }
1069 } else {
1070 if (ixjdebug & 0x0008) {
1071 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1072 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1073 j->cadence_f[4].off2);
1074 }
1075 j->cadence_f[4].state = 0;
1076 }
1077 } else if (j->cadence_f[4].state == 6) {
1078 if((time_after(jiffies, j->cadence_f[4].off3min) &&
1079 time_before(jiffies, j->cadence_f[4].off3max))) {
1080 j->cadence_f[4].state = 7;
1081 } else {
1082 if (ixjdebug & 0x0008) {
1083 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1084 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1085 j->cadence_f[4].off3);
1086 }
1087 j->cadence_f[4].state = 0;
1088 }
1089 } else {
1090 j->cadence_f[4].state = 0;
1091 }
1092 } else { /* Falling edge of RMR */
1093 j->pstn_ring_start = 0;
1094 j->pstn_ring_stop = jiffies;
1095 if (j->cadence_f[4].state == 1) {
1096 if(!j->cadence_f[4].on1) {
1097 j->cadence_f[4].state = 7;
1098 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1099 time_before(jiffies, j->cadence_f[4].on1max))) {
1100 if (j->cadence_f[4].off1) {
1101 j->cadence_f[4].state = 2;
1102 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1103 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1104 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1105 } else {
1106 j->cadence_f[4].state = 7;
1107 }
1108 } else {
1109 if (ixjdebug & 0x0008) {
1110 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1111 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1112 j->cadence_f[4].on1);
1113 }
1114 j->cadence_f[4].state = 0;
1115 }
1116 } else if (j->cadence_f[4].state == 3) {
1117 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1118 time_before(jiffies, j->cadence_f[4].on2max))) {
1119 if (j->cadence_f[4].off2) {
1120 j->cadence_f[4].state = 4;
1121 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1122 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1123 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1124 } else {
1125 j->cadence_f[4].state = 7;
1126 }
1127 } else {
1128 if (ixjdebug & 0x0008) {
1129 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1130 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1131 j->cadence_f[4].on2);
1132 }
1133 j->cadence_f[4].state = 0;
1134 }
1135 } else if (j->cadence_f[4].state == 5) {
1136 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1137 time_before(jiffies, j->cadence_f[4].on3max))) {
1138 if (j->cadence_f[4].off3) {
1139 j->cadence_f[4].state = 6;
1140 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1141 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1142 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1143 } else {
1144 j->cadence_f[4].state = 7;
1145 }
1146 } else {
1147 j->cadence_f[4].state = 0;
1148 }
1149 } else {
1150 if (ixjdebug & 0x0008) {
1151 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1152 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1153 j->cadence_f[4].on3);
1154 }
1155 j->cadence_f[4].state = 0;
1156 }
1157 }
1158 if (ixjdebug & 0x0010) {
1159 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1160 }
1161 if (ixjdebug & 0x0010) {
1162 switch(j->cadence_f[4].state) {
1163 case 1:
1164 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1165 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1166 break;
1167 case 2:
1168 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1169 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1170 break;
1171 case 3:
1172 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1173 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1174 break;
1175 case 4:
1176 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1177 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1178 break;
1179 case 5:
1180 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1181 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1182 break;
1183 case 6:
1184 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1185 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1186 break;
1187 }
1188 }
1189 }
1190 if (j->cadence_f[4].state == 7) {
1191 j->cadence_f[4].state = 0;
1192 j->pstn_ring_stop = jiffies;
1193 j->ex.bits.pstn_ring = 1;
1194 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1195 if(ixjdebug & 0x0008) {
1196 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1197 }
1198 }
1199 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1200 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1201 if(ixjdebug & 0x0008) {
1202 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1203 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1204 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1205 }
1206 j->pstn_ring_stop = j->pstn_ring_int = 0;
1207 daa_set_mode(j, SOP_PU_SLEEP);
1208 }
1209 outb_p(j->pld_scrw.byte, j->XILINXbase);
1210 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1211 ixj_daa_cid_read(j);
1212 j->ex.bits.caller_id = 1;
1213 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1214 j->pstn_cid_intr = 0;
1215 }
1216 if (daaint.bitreg.Cadence) {
1217 if(ixjdebug & 0x0008) {
1218 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1219 }
1220 daa_set_mode(j, SOP_PU_SLEEP);
1221 j->ex.bits.pstn_ring = 0;
1222 }
1223 break;
1224 case SOP_PU_CONVERSATION:
1225 if (daaint.bitreg.VDD_OK) {
1226 if(!daaint.bitreg.SI_0) {
1227 if (!j->pstn_winkstart) {
1228 if(ixjdebug & 0x0008) {
1229 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1230 }
1231 j->pstn_winkstart = jiffies;
1232 }
1233 } else {
1234 if (j->pstn_winkstart) {
1235 if(ixjdebug & 0x0008) {
1236 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1237 }
1238 j->pstn_winkstart = 0;
1239 }
1240 }
1241 }
1242 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1243 if(ixjdebug & 0x0008) {
1244 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1245 }
1246 daa_set_mode(j, SOP_PU_SLEEP);
1247 j->pstn_winkstart = 0;
1248 j->ex.bits.pstn_wink = 1;
1249 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1250 }
1251 break;
1252 }
1253 }
1254
1255 static void ixj_timeout(unsigned long ptr)
1256 {
1257 int board;
1258 unsigned long jifon;
1259 IXJ *j = (IXJ *)ptr;
1260 board = j->board;
1261
1262 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1263 ixj_perfmon(j->timerchecks);
1264 j->hookstate = ixj_hookstate(j);
1265 if (j->tone_state) {
1266 if (!(j->hookstate)) {
1267 ixj_cpt_stop(j);
1268 if (j->m_hook) {
1269 j->m_hook = 0;
1270 j->ex.bits.hookstate = 1;
1271 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1272 }
1273 clear_bit(board, &j->busyflags);
1274 ixj_add_timer(j);
1275 return;
1276 }
1277 if (j->tone_state == 1)
1278 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1279 else
1280 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1281 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1282 if (j->tone_state == 1) {
1283 ixj_play_tone(j, j->tone_index);
1284 if (j->dsp.low == 0x20) {
1285 clear_bit(board, &j->busyflags);
1286 ixj_add_timer(j);
1287 return;
1288 }
1289 } else {
1290 ixj_play_tone(j, 0);
1291 if (j->dsp.low == 0x20) {
1292 clear_bit(board, &j->busyflags);
1293 ixj_add_timer(j);
1294 return;
1295 }
1296 }
1297 } else {
1298 ixj_tone_timeout(j);
1299 if (j->flags.dialtone) {
1300 ixj_dialtone(j);
1301 }
1302 if (j->flags.busytone) {
1303 ixj_busytone(j);
1304 if (j->dsp.low == 0x20) {
1305 clear_bit(board, &j->busyflags);
1306 ixj_add_timer(j);
1307 return;
1308 }
1309 }
1310 if (j->flags.ringback) {
1311 ixj_ringback(j);
1312 if (j->dsp.low == 0x20) {
1313 clear_bit(board, &j->busyflags);
1314 ixj_add_timer(j);
1315 return;
1316 }
1317 }
1318 if (!j->tone_state) {
1319 ixj_cpt_stop(j);
1320 }
1321 }
1322 }
1323 if (!(j->tone_state && j->dsp.low == 0x20)) {
1324 if (IsRxReady(j)) {
1325 ixj_read_frame(j);
1326 }
1327 if (IsTxReady(j)) {
1328 ixj_write_frame(j);
1329 }
1330 }
1331 if (j->flags.cringing) {
1332 if (j->hookstate & 1) {
1333 j->flags.cringing = 0;
1334 ixj_ring_off(j);
1335 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1336 switch(j->cadence_f[5].state) {
1337 case 0:
1338 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1339 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1340 if(ixjdebug & 0x0004) {
1341 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1342 }
1343 ixj_ring_on(j);
1344 }
1345 j->cadence_f[5].state = 1;
1346 break;
1347 case 1:
1348 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1349 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1350 if(ixjdebug & 0x0004) {
1351 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1352 }
1353 ixj_ring_off(j);
1354 j->cadence_f[5].state = 2;
1355 }
1356 break;
1357 case 2:
1358 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1359 if(ixjdebug & 0x0004) {
1360 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1361 }
1362 ixj_ring_on(j);
1363 if (j->cadence_f[5].on2) {
1364 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1365 j->cadence_f[5].state = 3;
1366 } else {
1367 j->cadence_f[5].state = 7;
1368 }
1369 }
1370 break;
1371 case 3:
1372 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1373 if(ixjdebug & 0x0004) {
1374 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1375 }
1376 ixj_ring_off(j);
1377 if (j->cadence_f[5].off2) {
1378 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1379 j->cadence_f[5].state = 4;
1380 } else {
1381 j->cadence_f[5].state = 7;
1382 }
1383 }
1384 break;
1385 case 4:
1386 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1387 if(ixjdebug & 0x0004) {
1388 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1389 }
1390 ixj_ring_on(j);
1391 if (j->cadence_f[5].on3) {
1392 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1393 j->cadence_f[5].state = 5;
1394 } else {
1395 j->cadence_f[5].state = 7;
1396 }
1397 }
1398 break;
1399 case 5:
1400 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1401 if(ixjdebug & 0x0004) {
1402 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1403 }
1404 ixj_ring_off(j);
1405 if (j->cadence_f[5].off3) {
1406 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1407 j->cadence_f[5].state = 6;
1408 } else {
1409 j->cadence_f[5].state = 7;
1410 }
1411 }
1412 break;
1413 case 6:
1414 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1415 if(ixjdebug & 0x0004) {
1416 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1417 }
1418 j->cadence_f[5].state = 7;
1419 }
1420 break;
1421 case 7:
1422 if(ixjdebug & 0x0004) {
1423 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1424 }
1425 j->flags.cidring = 1;
1426 j->cadence_f[5].state = 0;
1427 break;
1428 }
1429 if (j->flags.cidring && !j->flags.cidsent) {
1430 j->flags.cidsent = 1;
1431 if(j->fskdcnt) {
1432 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1433 ixj_pre_cid(j);
1434 }
1435 j->flags.cidring = 0;
1436 }
1437 clear_bit(board, &j->busyflags);
1438 ixj_add_timer(j);
1439 return;
1440 } else {
1441 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1442 if (j->flags.cidring && !j->flags.cidsent) {
1443 j->flags.cidsent = 1;
1444 if(j->fskdcnt) {
1445 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1446 ixj_pre_cid(j);
1447 }
1448 j->flags.cidring = 0;
1449 }
1450 j->ring_cadence_t--;
1451 if (j->ring_cadence_t == -1)
1452 j->ring_cadence_t = 15;
1453 j->ring_cadence_jif = jiffies;
1454
1455 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1456 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1457 j->flags.firstring = 1;
1458 else
1459 ixj_ring_on(j);
1460 } else {
1461 ixj_ring_off(j);
1462 if(!j->flags.cidsent)
1463 j->flags.cidring = 1;
1464 }
1465 }
1466 clear_bit(board, &j->busyflags);
1467 ixj_add_timer(j);
1468 return;
1469 }
1470 }
1471 if (!j->flags.ringing) {
1472 if (j->hookstate) { /* & 1) { */
1473 if (j->dsp.low != 0x20 &&
1474 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1475 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1476 }
1477 LineMonitor(j);
1478 read_filters(j);
1479 ixj_WriteDSPCommand(0x511B, j);
1480 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1481 if (!j->m_hook && (j->hookstate & 1)) {
1482 j->m_hook = j->ex.bits.hookstate = 1;
1483 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1484 }
1485 } else {
1486 if (j->ex.bits.dtmf_ready) {
1487 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1488 }
1489 if (j->m_hook) {
1490 j->m_hook = 0;
1491 j->ex.bits.hookstate = 1;
1492 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1493 }
1494 }
1495 }
1496 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1497 ixj_pstn_state(j);
1498 }
1499 if (j->ex.bytes) {
1500 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1501 }
1502 clear_bit(board, &j->busyflags);
1503 }
1504 ixj_add_timer(j);
1505 }
1506
1507 static int ixj_status_wait(IXJ *j)
1508 {
1509 unsigned long jif;
1510
1511 jif = jiffies + ((60 * hertz) / 100);
1512 while (!IsStatusReady(j)) {
1513 ixj_perfmon(j->statuswait);
1514 if (time_after(jiffies, jif)) {
1515 ixj_perfmon(j->statuswaitfail);
1516 return -1;
1517 }
1518 }
1519 return 0;
1520 }
1521
1522 static int ixj_PCcontrol_wait(IXJ *j)
1523 {
1524 unsigned long jif;
1525
1526 jif = jiffies + ((60 * hertz) / 100);
1527 while (!IsPCControlReady(j)) {
1528 ixj_perfmon(j->pcontrolwait);
1529 if (time_after(jiffies, jif)) {
1530 ixj_perfmon(j->pcontrolwaitfail);
1531 return -1;
1532 }
1533 }
1534 return 0;
1535 }
1536
1537 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1538 {
1539 BYTES bytes;
1540 unsigned long jif;
1541
1542 atomic_inc(&j->DSPWrite);
1543 if(atomic_read(&j->DSPWrite) > 1) {
1544 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1545 return -1;
1546 }
1547 bytes.high = (cmd & 0xFF00) >> 8;
1548 bytes.low = cmd & 0x00FF;
1549 jif = jiffies + ((60 * hertz) / 100);
1550 while (!IsControlReady(j)) {
1551 ixj_perfmon(j->iscontrolready);
1552 if (time_after(jiffies, jif)) {
1553 ixj_perfmon(j->iscontrolreadyfail);
1554 atomic_dec(&j->DSPWrite);
1555 if(atomic_read(&j->DSPWrite) > 0) {
1556 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1557 while(atomic_read(&j->DSPWrite) > 0) {
1558 atomic_dec(&j->DSPWrite);
1559 }
1560 }
1561 return -1;
1562 }
1563 }
1564 outb(bytes.low, j->DSPbase + 6);
1565 outb(bytes.high, j->DSPbase + 7);
1566
1567 if (ixj_status_wait(j)) {
1568 j->ssr.low = 0xFF;
1569 j->ssr.high = 0xFF;
1570 atomic_dec(&j->DSPWrite);
1571 if(atomic_read(&j->DSPWrite) > 0) {
1572 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1573 while(atomic_read(&j->DSPWrite) > 0) {
1574 atomic_dec(&j->DSPWrite);
1575 }
1576 }
1577 return -1;
1578 }
1579 /* Read Software Status Register */
1580 j->ssr.low = inb_p(j->DSPbase + 2);
1581 j->ssr.high = inb_p(j->DSPbase + 3);
1582 atomic_dec(&j->DSPWrite);
1583 if(atomic_read(&j->DSPWrite) > 0) {
1584 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1585 while(atomic_read(&j->DSPWrite) > 0) {
1586 atomic_dec(&j->DSPWrite);
1587 }
1588 }
1589 return 0;
1590 }
1591
1592 /***************************************************************************
1593 *
1594 * General Purpose IO Register read routine
1595 *
1596 ***************************************************************************/
1597 static inline int ixj_gpio_read(IXJ *j)
1598 {
1599 if (ixj_WriteDSPCommand(0x5143, j))
1600 return -1;
1601
1602 j->gpio.bytes.low = j->ssr.low;
1603 j->gpio.bytes.high = j->ssr.high;
1604
1605 return 0;
1606 }
1607
1608 static inline void LED_SetState(int state, IXJ *j)
1609 {
1610 if (j->cardtype == QTI_LINEJACK) {
1611 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1612 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1613 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1614 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1615
1616 outb(j->pld_scrw.byte, j->XILINXbase);
1617 }
1618 }
1619
1620 /*********************************************************************
1621 * GPIO Pins are configured as follows on the Quicknet Internet
1622 * PhoneJACK Telephony Cards
1623 *
1624 * POTS Select GPIO_6=0 GPIO_7=0
1625 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1626 * Handset Select GPIO_6=1 GPIO_7=0
1627 *
1628 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1629 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1630 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1631 *
1632 * Hook Switch changes reported on GPIO_3
1633 *********************************************************************/
1634 static int ixj_set_port(IXJ *j, int arg)
1635 {
1636 if (j->cardtype == QTI_PHONEJACK_LITE) {
1637 if (arg != PORT_POTS)
1638 return 10;
1639 else
1640 return 0;
1641 }
1642 switch (arg) {
1643 case PORT_POTS:
1644 j->port = PORT_POTS;
1645 switch (j->cardtype) {
1646 case QTI_PHONECARD:
1647 if (j->flags.pcmciasct == 1)
1648 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1649 else
1650 return 11;
1651 break;
1652 case QTI_PHONEJACK_PCI:
1653 j->pld_slicw.pcib.mic = 0;
1654 j->pld_slicw.pcib.spk = 0;
1655 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1656 break;
1657 case QTI_LINEJACK:
1658 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1659 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1660 Software Control Register */
1661 return 2;
1662 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1663
1664 outb(j->pld_scrw.byte, j->XILINXbase);
1665 j->pld_clock.byte = 0;
1666 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1667 j->pld_slicw.bits.rly1 = 1;
1668 j->pld_slicw.bits.spken = 0;
1669 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1670 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1671 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1672 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1673 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1674 ixj_mixer(0x0E80, j); /*Mic mute */
1675 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1676 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1677 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1678 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1679 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1680 break;
1681 case QTI_PHONEJACK:
1682 j->gpio.bytes.high = 0x0B;
1683 j->gpio.bits.gpio6 = 0;
1684 j->gpio.bits.gpio7 = 0;
1685 ixj_WriteDSPCommand(j->gpio.word, j);
1686 break;
1687 }
1688 break;
1689 case PORT_PSTN:
1690 if (j->cardtype == QTI_LINEJACK) {
1691 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1692
1693 j->pld_slicw.bits.rly3 = 0;
1694 j->pld_slicw.bits.rly1 = 1;
1695 j->pld_slicw.bits.spken = 0;
1696 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1697 j->port = PORT_PSTN;
1698 } else {
1699 return 4;
1700 }
1701 break;
1702 case PORT_SPEAKER:
1703 j->port = PORT_SPEAKER;
1704 switch (j->cardtype) {
1705 case QTI_PHONECARD:
1706 if (j->flags.pcmciasct) {
1707 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1708 }
1709 break;
1710 case QTI_PHONEJACK_PCI:
1711 j->pld_slicw.pcib.mic = 1;
1712 j->pld_slicw.pcib.spk = 1;
1713 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1714 break;
1715 case QTI_LINEJACK:
1716 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1717 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1718 Software Control Register */
1719 return 2;
1720 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1721
1722 outb(j->pld_scrw.byte, j->XILINXbase);
1723 j->pld_clock.byte = 0;
1724 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1725 j->pld_slicw.bits.rly1 = 1;
1726 j->pld_slicw.bits.spken = 1;
1727 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1728 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1729 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1730 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1731 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1732 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1733 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1734 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1735 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1736 break;
1737 case QTI_PHONEJACK:
1738 j->gpio.bytes.high = 0x0B;
1739 j->gpio.bits.gpio6 = 0;
1740 j->gpio.bits.gpio7 = 1;
1741 ixj_WriteDSPCommand(j->gpio.word, j);
1742 break;
1743 }
1744 break;
1745 case PORT_HANDSET:
1746 if (j->cardtype != QTI_PHONEJACK) {
1747 return 5;
1748 } else {
1749 j->gpio.bytes.high = 0x0B;
1750 j->gpio.bits.gpio6 = 1;
1751 j->gpio.bits.gpio7 = 0;
1752 ixj_WriteDSPCommand(j->gpio.word, j);
1753 j->port = PORT_HANDSET;
1754 }
1755 break;
1756 default:
1757 return 6;
1758 break;
1759 }
1760 return 0;
1761 }
1762
1763 static int ixj_set_pots(IXJ *j, int arg)
1764 {
1765 if (j->cardtype == QTI_LINEJACK) {
1766 if (arg) {
1767 if (j->port == PORT_PSTN) {
1768 j->pld_slicw.bits.rly1 = 0;
1769 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1770 j->flags.pots_pstn = 1;
1771 return 1;
1772 } else {
1773 j->flags.pots_pstn = 0;
1774 return 0;
1775 }
1776 } else {
1777 j->pld_slicw.bits.rly1 = 1;
1778 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1779 j->flags.pots_pstn = 0;
1780 return 1;
1781 }
1782 } else {
1783 return 0;
1784 }
1785 }
1786
1787 static void ixj_ring_on(IXJ *j)
1788 {
1789 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1790 {
1791 if (ixjdebug & 0x0004)
1792 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1793
1794 j->gpio.bytes.high = 0x0B;
1795 j->gpio.bytes.low = 0x00;
1796 j->gpio.bits.gpio1 = 1;
1797 j->gpio.bits.gpio2 = 1;
1798 j->gpio.bits.gpio5 = 0;
1799 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1800 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1801 {
1802 if (ixjdebug & 0x0004)
1803 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1804
1805 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1806 }
1807 }
1808
1809 static int ixj_siadc(IXJ *j, int val)
1810 {
1811 if(j->cardtype == QTI_PHONECARD){
1812 if(j->flags.pcmciascp){
1813 if(val == -1)
1814 return j->siadc.bits.rxg;
1815
1816 if(val < 0 || val > 0x1F)
1817 return -1;
1818
1819 j->siadc.bits.hom = 0; /* Handset Out Mute */
1820 j->siadc.bits.lom = 0; /* Line Out Mute */
1821 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1822 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1823 j->psccr.bits.rw = 0; /* Read / Write flag */
1824 j->psccr.bits.dev = 0;
1825 outb(j->siadc.byte, j->XILINXbase + 0x00);
1826 outb(j->psccr.byte, j->XILINXbase + 0x01);
1827 ixj_PCcontrol_wait(j);
1828 return j->siadc.bits.rxg;
1829 }
1830 }
1831 return -1;
1832 }
1833
1834 static int ixj_sidac(IXJ *j, int val)
1835 {
1836 if(j->cardtype == QTI_PHONECARD){
1837 if(j->flags.pcmciascp){
1838 if(val == -1)
1839 return j->sidac.bits.txg;
1840
1841 if(val < 0 || val > 0x1F)
1842 return -1;
1843
1844 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1845 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1846 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1847 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1848 j->psccr.bits.rw = 0; /* Read / Write flag */
1849 j->psccr.bits.dev = 0;
1850 outb(j->sidac.byte, j->XILINXbase + 0x00);
1851 outb(j->psccr.byte, j->XILINXbase + 0x01);
1852 ixj_PCcontrol_wait(j);
1853 return j->sidac.bits.txg;
1854 }
1855 }
1856 return -1;
1857 }
1858
1859 static int ixj_pcmcia_cable_check(IXJ *j)
1860 {
1861 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1862 if (!j->flags.pcmciastate) {
1863 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1864 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1865 j->flags.pcmciastate = 4;
1866 return 0;
1867 }
1868 if (j->pccr1.bits.ed) {
1869 j->pccr1.bits.ed = 0;
1870 j->psccr.bits.dev = 3;
1871 j->psccr.bits.rw = 1;
1872 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1873 ixj_PCcontrol_wait(j);
1874 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1875 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1876 j->psccr.bits.dev = 3;
1877 j->psccr.bits.rw = 0;
1878 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1879 ixj_PCcontrol_wait(j);
1880 return j->pslic.bits.led2 ? 1 : 0;
1881 } else if (j->flags.pcmciasct) {
1882 return j->r_hook;
1883 } else {
1884 return 1;
1885 }
1886 } else if (j->flags.pcmciastate == 4) {
1887 if (!j->pccr1.bits.drf) {
1888 j->flags.pcmciastate = 3;
1889 }
1890 return 0;
1891 } else if (j->flags.pcmciastate == 3) {
1892 j->pccr2.bits.pwr = 0;
1893 j->pccr2.bits.rstc = 1;
1894 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1895 j->checkwait = jiffies + (hertz * 2);
1896 j->flags.incheck = 1;
1897 j->flags.pcmciastate = 2;
1898 return 0;
1899 } else if (j->flags.pcmciastate == 2) {
1900 if (j->flags.incheck) {
1901 if (time_before(jiffies, j->checkwait)) {
1902 return 0;
1903 } else {
1904 j->flags.incheck = 0;
1905 }
1906 }
1907 j->pccr2.bits.pwr = 0;
1908 j->pccr2.bits.rstc = 0;
1909 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1910 j->flags.pcmciastate = 1;
1911 return 0;
1912 } else if (j->flags.pcmciastate == 1) {
1913 j->flags.pcmciastate = 0;
1914 if (!j->pccr1.bits.drf) {
1915 j->psccr.bits.dev = 3;
1916 j->psccr.bits.rw = 1;
1917 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1918 ixj_PCcontrol_wait(j);
1919 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1920
1921 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1922
1923 if (j->flags.pcmciasct == 3) {
1924 j->flags.pcmciastate = 4;
1925 return 0;
1926 } else if (j->flags.pcmciasct == 0) {
1927 j->pccr2.bits.pwr = 1;
1928 j->pccr2.bits.rstc = 0;
1929 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1930 j->port = PORT_SPEAKER;
1931 } else {
1932 j->port = PORT_POTS;
1933 }
1934 j->sic1.bits.cpd = 0; /* Chip Power Down */
1935 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1936 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1937 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1938 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1939 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1940 j->psccr.bits.rw = 0; /* Read / Write flag */
1941 j->psccr.bits.dev = 0;
1942 outb(j->sic1.byte, j->XILINXbase + 0x00);
1943 outb(j->psccr.byte, j->XILINXbase + 0x01);
1944 ixj_PCcontrol_wait(j);
1945
1946 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1947 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1948 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1949 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1950 j->sic2.bits.hpd = 0; /* HPF disable */
1951 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1952 j->psccr.bits.rw = 0; /* Read / Write flag */
1953 j->psccr.bits.dev = 0;
1954 outb(j->sic2.byte, j->XILINXbase + 0x00);
1955 outb(j->psccr.byte, j->XILINXbase + 0x01);
1956 ixj_PCcontrol_wait(j);
1957
1958 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1959 j->psccr.bits.rw = 0; /* Read / Write flag */
1960 j->psccr.bits.dev = 0;
1961 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1962 outb(j->psccr.byte, j->XILINXbase + 0x01);
1963 ixj_PCcontrol_wait(j);
1964
1965 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1966 j->psccr.bits.rw = 0; /* Read / Write flag */
1967 j->psccr.bits.dev = 0;
1968 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1969 outb(j->psccr.byte, j->XILINXbase + 0x01);
1970 ixj_PCcontrol_wait(j);
1971
1972 j->sirxg.bits.lig = 1; /* Line In Gain */
1973 j->sirxg.bits.lim = 1; /* Line In Mute */
1974 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1975 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1976 j->sirxg.bits.him = 0; /* Handset In Mute */
1977 j->sirxg.bits.iir = 1; /* IIR */
1978 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1979 j->psccr.bits.rw = 0; /* Read / Write flag */
1980 j->psccr.bits.dev = 0;
1981 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1982 outb(j->psccr.byte, j->XILINXbase + 0x01);
1983 ixj_PCcontrol_wait(j);
1984
1985 ixj_siadc(j, 0x17);
1986 ixj_sidac(j, 0x1D);
1987
1988 j->siaatt.bits.sot = 0;
1989 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1990 j->psccr.bits.rw = 0; /* Read / Write flag */
1991 j->psccr.bits.dev = 0;
1992 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1993 outb(j->psccr.byte, j->XILINXbase + 0x01);
1994 ixj_PCcontrol_wait(j);
1995
1996 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1997 j->psccr.byte = j->pslic.byte = 0;
1998 j->pslic.bits.powerdown = 1;
1999 j->psccr.bits.dev = 3;
2000 j->psccr.bits.rw = 0;
2001 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2002 ixj_PCcontrol_wait(j);
2003 }
2004 }
2005 return 0;
2006 } else {
2007 j->flags.pcmciascp = 0;
2008 return 0;
2009 }
2010 return 0;
2011 }
2012
2013 static int ixj_hookstate(IXJ *j)
2014 {
2015 unsigned long det;
2016 int fOffHook = 0;
2017
2018 switch (j->cardtype) {
2019 case QTI_PHONEJACK:
2020 ixj_gpio_read(j);
2021 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
2022 break;
2023 case QTI_LINEJACK:
2024 case QTI_PHONEJACK_LITE:
2025 case QTI_PHONEJACK_PCI:
2026 SLIC_GetState(j);
2027 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
2028 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
2029 if(fOffHook != j->p_hook) {
2030 if(!j->checkwait) {
2031 j->checkwait = jiffies;
2032 }
2033 if(time_before(jiffies, j->checkwait + 2)) {
2034 fOffHook ^= 1;
2035 } else {
2036 j->checkwait = 0;
2037 }
2038 j->p_hook = fOffHook;
2039 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
2040 }
2041 } else {
2042 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
2043 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
2044 if (j->flags.ringing || j->flags.cringing) {
2045 if (!in_interrupt()) {
2046 det = jiffies + (hertz / 50);
2047 while (time_before(jiffies, det)) {
2048 set_current_state(TASK_INTERRUPTIBLE);
2049 schedule_timeout(1);
2050 }
2051 }
2052 SLIC_GetState(j);
2053 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
2054 ixj_ring_on(j);
2055 }
2056 }
2057 if (j->cardtype == QTI_PHONEJACK_PCI) {
2058 j->pld_scrr.byte = inb_p(j->XILINXbase);
2059 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
2060 } else
2061 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
2062 }
2063 }
2064 break;
2065 case QTI_PHONECARD:
2066 fOffHook = ixj_pcmcia_cable_check(j);
2067 break;
2068 }
2069 if (j->r_hook != fOffHook) {
2070 j->r_hook = fOffHook;
2071 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
2072 j->ex.bits.hookstate = 1;
2073 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
2074 } else if (!fOffHook) {
2075 j->flash_end = jiffies + ((60 * hertz) / 100);
2076 }
2077 }
2078 if (fOffHook) {
2079 if(time_before(jiffies, j->flash_end)) {
2080 j->ex.bits.flash = 1;
2081 j->flash_end = 0;
2082 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
2083 }
2084 } else {
2085 if(time_before(jiffies, j->flash_end)) {
2086 fOffHook = 1;
2087 }
2088 }
2089
2090 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
2091 fOffHook |= 2;
2092
2093 if (j->port == PORT_SPEAKER) {
2094 if(j->cardtype == QTI_PHONECARD) {
2095 if(j->flags.pcmciascp && j->flags.pcmciasct) {
2096 fOffHook |= 2;
2097 }
2098 } else {
2099 fOffHook |= 2;
2100 }
2101 }
2102
2103 if (j->port == PORT_HANDSET)
2104 fOffHook |= 2;
2105
2106 return fOffHook;
2107 }
2108
2109 static void ixj_ring_off(IXJ *j)
2110 {
2111 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2112 {
2113 if (ixjdebug & 0x0004)
2114 printk(KERN_INFO "IXJ Ring Off\n");
2115 j->gpio.bytes.high = 0x0B;
2116 j->gpio.bytes.low = 0x00;
2117 j->gpio.bits.gpio1 = 0;
2118 j->gpio.bits.gpio2 = 1;
2119 j->gpio.bits.gpio5 = 0;
2120 ixj_WriteDSPCommand(j->gpio.word, j);
2121 } else /* Internet LineJACK */
2122 {
2123 if (ixjdebug & 0x0004)
2124 printk(KERN_INFO "IXJ Ring Off\n");
2125
2126 if(!j->flags.cidplay)
2127 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2128
2129 SLIC_GetState(j);
2130 }
2131 }
2132
2133 static void ixj_ring_start(IXJ *j)
2134 {
2135 j->flags.cringing = 1;
2136 if (ixjdebug & 0x0004)
2137 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2138 if (ixj_hookstate(j) & 1) {
2139 if (j->port == PORT_POTS)
2140 ixj_ring_off(j);
2141 j->flags.cringing = 0;
2142 if (ixjdebug & 0x0004)
2143 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2144 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2145 j->ring_cadence_jif = jiffies;
2146 j->flags.cidsent = j->flags.cidring = 0;
2147 j->cadence_f[5].state = 0;
2148 if(j->cadence_f[5].on1)
2149 ixj_ring_on(j);
2150 } else {
2151 j->ring_cadence_jif = jiffies;
2152 j->ring_cadence_t = 15;
2153 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2154 ixj_ring_on(j);
2155 } else {
2156 ixj_ring_off(j);
2157 }
2158 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2159 }
2160 }
2161
2162 static int ixj_ring(IXJ *j)
2163 {
2164 char cntr;
2165 unsigned long jif, det;
2166
2167 j->flags.ringing = 1;
2168 if (ixj_hookstate(j) & 1) {
2169 ixj_ring_off(j);
2170 j->flags.ringing = 0;
2171 return 1;
2172 }
2173 det = 0;
2174 for (cntr = 0; cntr < j->maxrings; cntr++) {
2175 jif = jiffies + (1 * hertz);
2176 ixj_ring_on(j);
2177 while (time_before(jiffies, jif)) {
2178 if (ixj_hookstate(j) & 1) {
2179 ixj_ring_off(j);
2180 j->flags.ringing = 0;
2181 return 1;
2182 }
2183 set_current_state(TASK_INTERRUPTIBLE);
2184 schedule_timeout(1);
2185 if (signal_pending(current))
2186 break;
2187 }
2188 jif = jiffies + (3 * hertz);
2189 ixj_ring_off(j);
2190 while (time_before(jiffies, jif)) {
2191 if (ixj_hookstate(j) & 1) {
2192 det = jiffies + (hertz / 100);
2193 while (time_before(jiffies, det)) {
2194 set_current_state(TASK_INTERRUPTIBLE);
2195 schedule_timeout(1);
2196 if (signal_pending(current))
2197 break;
2198 }
2199 if (ixj_hookstate(j) & 1) {
2200 j->flags.ringing = 0;
2201 return 1;
2202 }
2203 }
2204 set_current_state(TASK_INTERRUPTIBLE);
2205 schedule_timeout(1);
2206 if (signal_pending(current))
2207 break;
2208 }
2209 }
2210 ixj_ring_off(j);
2211 j->flags.ringing = 0;
2212 return 0;
2213 }
2214
2215 static int ixj_open(struct phone_device *p, struct file *file_p)
2216 {
2217 IXJ *j = get_ixj(p->board);
2218 file_p->private_data = j;
2219
2220 if (!j->DSPbase)
2221 return -ENODEV;
2222
2223 if (file_p->f_mode & FMODE_READ) {
2224 if(!j->readers) {
2225 j->readers++;
2226 } else {
2227 return -EBUSY;
2228 }
2229 }
2230
2231 if (file_p->f_mode & FMODE_WRITE) {
2232 if(!j->writers) {
2233 j->writers++;
2234 } else {
2235 if (file_p->f_mode & FMODE_READ){
2236 j->readers--;
2237 }
2238 return -EBUSY;
2239 }
2240 }
2241
2242 if (j->cardtype == QTI_PHONECARD) {
2243 j->pslic.bits.powerdown = 0;
2244 j->psccr.bits.dev = 3;
2245 j->psccr.bits.rw = 0;
2246 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2247 ixj_PCcontrol_wait(j);
2248 }
2249
2250 j->flags.cidplay = 0;
2251 j->flags.cidcw_ack = 0;
2252
2253 if (ixjdebug & 0x0002)
2254 printk(KERN_INFO "Opening board %d\n", p->board);
2255
2256 j->framesread = j->frameswritten = 0;
2257 return 0;
2258 }
2259
2260 int ixj_release(struct inode *inode, struct file *file_p)
2261 {
2262 IXJ_TONE ti;
2263 int cnt;
2264 IXJ *j = file_p->private_data;
2265 int board = j->p.board;
2266
2267 /*
2268 * Set up locks to ensure that only one process is talking to the DSP at a time.
2269 * This is necessary to keep the DSP from locking up.
2270 */
2271 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2272 set_current_state(TASK_INTERRUPTIBLE);
2273 schedule_timeout(1);
2274 }
2275 if (ixjdebug & 0x0002)
2276 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2277
2278 if (j->cardtype == QTI_PHONECARD)
2279 ixj_set_port(j, PORT_SPEAKER);
2280 else
2281 ixj_set_port(j, PORT_POTS);
2282
2283 aec_stop(j);
2284 ixj_play_stop(j);
2285 ixj_record_stop(j);
2286 set_play_volume(j, 0x100);
2287 set_rec_volume(j, 0x100);
2288 ixj_ring_off(j);
2289
2290 /* Restore the tone table to default settings. */
2291 ti.tone_index = 10;
2292 ti.gain0 = 1;
2293 ti.freq0 = hz941;
2294 ti.gain1 = 0;
2295 ti.freq1 = hz1209;
2296 ixj_init_tone(j, &ti);
2297 ti.tone_index = 11;
2298 ti.gain0 = 1;
2299 ti.freq0 = hz941;
2300 ti.gain1 = 0;
2301 ti.freq1 = hz1336;
2302 ixj_init_tone(j, &ti);
2303 ti.tone_index = 12;
2304 ti.gain0 = 1;
2305 ti.freq0 = hz941;
2306 ti.gain1 = 0;
2307 ti.freq1 = hz1477;
2308 ixj_init_tone(j, &ti);
2309 ti.tone_index = 13;
2310 ti.gain0 = 1;
2311 ti.freq0 = hz800;
2312 ti.gain1 = 0;
2313 ti.freq1 = 0;
2314 ixj_init_tone(j, &ti);
2315 ti.tone_index = 14;
2316 ti.gain0 = 1;
2317 ti.freq0 = hz1000;
2318 ti.gain1 = 0;
2319 ti.freq1 = 0;
2320 ixj_init_tone(j, &ti);
2321 ti.tone_index = 15;
2322 ti.gain0 = 1;
2323 ti.freq0 = hz1250;
2324 ti.gain1 = 0;
2325 ti.freq1 = 0;
2326 ixj_init_tone(j, &ti);
2327 ti.tone_index = 16;
2328 ti.gain0 = 1;
2329 ti.freq0 = hz950;
2330 ti.gain1 = 0;
2331 ti.freq1 = 0;
2332 ixj_init_tone(j, &ti);
2333 ti.tone_index = 17;
2334 ti.gain0 = 1;
2335 ti.freq0 = hz1100;
2336 ti.gain1 = 0;
2337 ti.freq1 = 0;
2338 ixj_init_tone(j, &ti);
2339 ti.tone_index = 18;
2340 ti.gain0 = 1;
2341 ti.freq0 = hz1400;
2342 ti.gain1 = 0;
2343 ti.freq1 = 0;
2344 ixj_init_tone(j, &ti);
2345 ti.tone_index = 19;
2346 ti.gain0 = 1;
2347 ti.freq0 = hz1500;
2348 ti.gain1 = 0;
2349 ti.freq1 = 0;
2350 ixj_init_tone(j, &ti);
2351 ti.tone_index = 20;
2352 ti.gain0 = 1;
2353 ti.freq0 = hz1600;
2354 ti.gain1 = 0;
2355 ti.freq1 = 0;
2356 ixj_init_tone(j, &ti);
2357 ti.tone_index = 21;
2358 ti.gain0 = 1;
2359 ti.freq0 = hz1800;
2360 ti.gain1 = 0;
2361 ti.freq1 = 0;
2362 ixj_init_tone(j, &ti);
2363 ti.tone_index = 22;
2364 ti.gain0 = 1;
2365 ti.freq0 = hz2100;
2366 ti.gain1 = 0;
2367 ti.freq1 = 0;
2368 ixj_init_tone(j, &ti);
2369 ti.tone_index = 23;
2370 ti.gain0 = 1;
2371 ti.freq0 = hz1300;
2372 ti.gain1 = 0;
2373 ti.freq1 = 0;
2374 ixj_init_tone(j, &ti);
2375 ti.tone_index = 24;
2376 ti.gain0 = 1;
2377 ti.freq0 = hz2450;
2378 ti.gain1 = 0;
2379 ti.freq1 = 0;
2380 ixj_init_tone(j, &ti);
2381 ti.tone_index = 25;
2382 ti.gain0 = 1;
2383 ti.freq0 = hz350;
2384 ti.gain1 = 0;
2385 ti.freq1 = hz440;
2386 ixj_init_tone(j, &ti);
2387 ti.tone_index = 26;
2388 ti.gain0 = 1;
2389 ti.freq0 = hz440;
2390 ti.gain1 = 0;
2391 ti.freq1 = hz480;
2392 ixj_init_tone(j, &ti);
2393 ti.tone_index = 27;
2394 ti.gain0 = 1;
2395 ti.freq0 = hz480;
2396 ti.gain1 = 0;
2397 ti.freq1 = hz620;
2398 ixj_init_tone(j, &ti);
2399
2400 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2401
2402 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2403
2404 j->ex.bits.dtmf_ready = 0;
2405 j->dtmf_state = 0;
2406 j->dtmf_wp = j->dtmf_rp = 0;
2407 j->rec_mode = j->play_mode = -1;
2408 j->flags.ringing = 0;
2409 j->maxrings = MAXRINGS;
2410 j->ring_cadence = USA_RING_CADENCE;
2411 if(j->cadence_f[5].enable) {
2412 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2413 }
2414 j->drybuffer = 0;
2415 j->winktime = 320;
2416 j->flags.dtmf_oob = 0;
2417 for (cnt = 0; cnt < 4; cnt++)
2418 j->cadence_f[cnt].enable = 0;
2419
2420 idle(j);
2421
2422 if(j->cardtype == QTI_PHONECARD) {
2423 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2424 }
2425
2426 if (file_p->f_mode & FMODE_READ)
2427 j->readers--;
2428 if (file_p->f_mode & FMODE_WRITE)
2429 j->writers--;
2430
2431 if (j->read_buffer && !j->readers) {
2432 kfree(j->read_buffer);
2433 j->read_buffer = NULL;
2434 j->read_buffer_size = 0;
2435 }
2436 if (j->write_buffer && !j->writers) {
2437 kfree(j->write_buffer);
2438 j->write_buffer = NULL;
2439 j->write_buffer_size = 0;
2440 }
2441 j->rec_codec = j->play_codec = 0;
2442 j->rec_frame_size = j->play_frame_size = 0;
2443 j->flags.cidsent = j->flags.cidring = 0;
2444 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2445
2446 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2447 ixj_set_port(j, PORT_PSTN);
2448 daa_set_mode(j, SOP_PU_SLEEP);
2449 ixj_set_pots(j, 1);
2450 }
2451 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2452
2453 /* Set up the default signals for events */
2454 for (cnt = 0; cnt < 35; cnt++)
2455 j->ixj_signals[cnt] = SIGIO;
2456
2457 /* Set the excetion signal enable flags */
2458 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2459 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 =
2460 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;
2461
2462 file_p->private_data = NULL;
2463 clear_bit(board, &j->busyflags);
2464 return 0;
2465 }
2466
2467 static int read_filters(IXJ *j)
2468 {
2469 unsigned short fc, cnt, trg;
2470 int var;
2471
2472 trg = 0;
2473 if (ixj_WriteDSPCommand(0x5144, j)) {
2474 if(ixjdebug & 0x0001) {
2475 printk(KERN_INFO "Read Frame Counter failed!\n");
2476 }
2477 return -1;
2478 }
2479 fc = j->ssr.high << 8 | j->ssr.low;
2480 if (fc == j->frame_count)
2481 return 1;
2482
2483 j->frame_count = fc;
2484
2485 if (j->dtmf_proc)
2486 return 1;
2487
2488 var = 10;
2489
2490 for (cnt = 0; cnt < 4; cnt++) {
2491 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2492 if(ixjdebug & 0x0001) {
2493 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2494 }
2495 return -1;
2496 }
2497 if (ixj_WriteDSPCommand(0x515C, j)) {
2498 if(ixjdebug & 0x0001) {
2499 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2500 }
2501 return -1;
2502 }
2503 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2504
2505 if (j->cadence_f[cnt].enable) {
2506 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2507 if (j->cadence_f[cnt].state == 0) {
2508 j->cadence_f[cnt].state = 1;
2509 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2510 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2511 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2512 } else if (j->cadence_f[cnt].state == 2 &&
2513 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2514 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2515 if (j->cadence_f[cnt].on2) {
2516 j->cadence_f[cnt].state = 3;
2517 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2518 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2519 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2520 } else {
2521 j->cadence_f[cnt].state = 7;
2522 }
2523 } else if (j->cadence_f[cnt].state == 4 &&
2524 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2525 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2526 if (j->cadence_f[cnt].on3) {
2527 j->cadence_f[cnt].state = 5;
2528 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2529 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2530 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2531 } else {
2532 j->cadence_f[cnt].state = 7;
2533 }
2534 } else {
2535 j->cadence_f[cnt].state = 0;
2536 }
2537 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2538 if (j->cadence_f[cnt].state == 1) {
2539 if(!j->cadence_f[cnt].on1) {
2540 j->cadence_f[cnt].state = 7;
2541 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2542 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2543 if(j->cadence_f[cnt].off1) {
2544 j->cadence_f[cnt].state = 2;
2545 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2546 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2547 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2548 } else {
2549 j->cadence_f[cnt].state = 7;
2550 }
2551 } else {
2552 j->cadence_f[cnt].state = 0;
2553 }
2554 } else if (j->cadence_f[cnt].state == 3) {
2555 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2556 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2557 if(j->cadence_f[cnt].off2) {
2558 j->cadence_f[cnt].state = 4;
2559 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2560 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2561 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2562 } else {
2563 j->cadence_f[cnt].state = 7;
2564 }
2565 } else {
2566 j->cadence_f[cnt].state = 0;
2567 }
2568 } else if (j->cadence_f[cnt].state == 5) {
2569 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2570 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2571 if(j->cadence_f[cnt].off3) {
2572 j->cadence_f[cnt].state = 6;
2573 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2574 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2575 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2576 } else {
2577 j->cadence_f[cnt].state = 7;
2578 }
2579 } else {
2580 j->cadence_f[cnt].state = 0;
2581 }
2582 } else {
2583 j->cadence_f[cnt].state = 0;
2584 }
2585 } else {
2586 switch(j->cadence_f[cnt].state) {
2587 case 1:
2588 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2589 !j->cadence_f[cnt].off1 &&
2590 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2591 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2592 j->cadence_f[cnt].state = 7;
2593 }
2594 break;
2595 case 3:
2596 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2597 !j->cadence_f[cnt].off2 &&
2598 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2599 j->cadence_f[cnt].state = 7;
2600 }
2601 break;
2602 case 5:
2603 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2604 !j->cadence_f[cnt].off3) {
2605 j->cadence_f[cnt].state = 7;
2606 }
2607 break;
2608 }
2609 }
2610
2611 if (ixjdebug & 0x0040) {
2612 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2613 switch(j->cadence_f[cnt].state) {
2614 case 0:
2615 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2616 break;
2617 case 1:
2618 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2619 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2620 break;
2621 case 2:
2622 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2623 j->cadence_f[cnt].off1max);
2624 break;
2625 case 3:
2626 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2627 j->cadence_f[cnt].on2max);
2628 break;
2629 case 4:
2630 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2631 j->cadence_f[cnt].off2max);
2632 break;
2633 case 5:
2634 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2635 j->cadence_f[cnt].on3max);
2636 break;
2637 case 6:
2638 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2639 j->cadence_f[cnt].off3max);
2640 break;
2641 }
2642 }
2643 }
2644 if (j->cadence_f[cnt].state == 7) {
2645 j->cadence_f[cnt].state = 0;
2646 if (j->cadence_f[cnt].enable == 1)
2647 j->cadence_f[cnt].enable = 0;
2648 switch (cnt) {
2649 case 0:
2650 if(ixjdebug & 0x0020) {
2651 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2652 }
2653 j->ex.bits.fc0 = 1;
2654 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2655 break;
2656 case 1:
2657 if(ixjdebug & 0x0020) {
2658 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2659 }
2660 j->ex.bits.fc1 = 1;
2661 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2662 break;
2663 case 2:
2664 if(ixjdebug & 0x0020) {
2665 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2666 }
2667 j->ex.bits.fc2 = 1;
2668 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2669 break;
2670 case 3:
2671 if(ixjdebug & 0x0020) {
2672 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2673 }
2674 j->ex.bits.fc3 = 1;
2675 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2676 break;
2677 }
2678 }
2679 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2680 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2681 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2682 trg = 1;
2683 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2684 trg = 0;
2685 }
2686 switch (cnt) {
2687 case 0:
2688 if(ixjdebug & 0x0020) {
2689 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2690 }
2691 j->ex.bits.f0 = 1;
2692 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2693 break;
2694 case 1:
2695 if(ixjdebug & 0x0020) {
2696 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2697 }
2698 j->ex.bits.f1 = 1;
2699 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2700 break;
2701 case 2:
2702 if(ixjdebug & 0x0020) {
2703 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2704 }
2705 j->ex.bits.f2 = 1;
2706 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2707 break;
2708 case 3:
2709 if(ixjdebug & 0x0020) {
2710 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2711 }
2712 j->ex.bits.f3 = 1;
2713 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2714 break;
2715 }
2716 }
2717 }
2718 return 0;
2719 }
2720
2721 static int LineMonitor(IXJ *j)
2722 {
2723 if (j->dtmf_proc) {
2724 return -1;
2725 }
2726 j->dtmf_proc = 1;
2727
2728 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2729 return -1;
2730
2731 j->dtmf.bytes.high = j->ssr.high;
2732 j->dtmf.bytes.low = j->ssr.low;
2733 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2734 j->dtmf_state = 1;
2735 j->dtmf_current = j->dtmf.bits.digit;
2736 }
2737 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2738 {
2739 if(!j->cidcw_wait) {
2740 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2741 j->dtmf_wp++;
2742 if (j->dtmf_wp == 79)
2743 j->dtmf_wp = 0;
2744 j->ex.bits.dtmf_ready = 1;
2745 if(j->ex_sig.bits.dtmf_ready) {
2746 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2747 }
2748 }
2749 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2750 if(ixjdebug & 0x0020) {
2751 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2752 }
2753 j->flags.cidcw_ack = 1;
2754 }
2755 j->dtmf_state = 0;
2756 }
2757 j->dtmf_proc = 0;
2758
2759 return 0;
2760 }
2761
2762 /************************************************************************
2763 *
2764 * Functions to allow alaw <-> ulaw conversions.
2765 *
2766 ************************************************************************/
2767
2768 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2769 {
2770 static unsigned char table_ulaw2alaw[] =
2771 {
2772 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2773 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2774 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2775 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2776 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2777 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2778 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2779 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2780 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2781 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2782 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2783 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2784 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2785 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2786 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2787 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2788 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2789 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2790 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2791 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2792 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2793 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2794 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2795 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2796 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2797 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2798 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2799 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2800 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2801 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2802 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2803 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2804 };
2805
2806 while (len--)
2807 {
2808 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2809 buff++;
2810 }
2811 }
2812
2813 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2814 {
2815 static unsigned char table_alaw2ulaw[] =
2816 {
2817 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2818 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2819 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2820 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2821 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2822 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2823 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2824 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2825 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2826 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2827 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2828 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2829 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2830 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2831 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2832 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2833 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2834 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2835 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2836 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2837 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2838 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2839 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2840 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2841 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2842 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2843 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2844 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2845 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2846 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2847 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2848 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2849 };
2850
2851 while (len--)
2852 {
2853 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2854 buff++;
2855 }
2856 }
2857
2858 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2859 {
2860 unsigned long i = *ppos;
2861 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2862
2863 DECLARE_WAITQUEUE(wait, current);
2864
2865 if (j->flags.inread)
2866 return -EALREADY;
2867
2868 j->flags.inread = 1;
2869
2870 add_wait_queue(&j->read_q, &wait);
2871 set_current_state(TASK_INTERRUPTIBLE);
2872 mb();
2873
2874 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2875 ++j->read_wait;
2876 if (file_p->f_flags & O_NONBLOCK) {
2877 set_current_state(TASK_RUNNING);
2878 remove_wait_queue(&j->read_q, &wait);
2879 j->flags.inread = 0;
2880 return -EAGAIN;
2881 }
2882 if (!ixj_hookstate(j)) {
2883 set_current_state(TASK_RUNNING);
2884 remove_wait_queue(&j->read_q, &wait);
2885 j->flags.inread = 0;
2886 return 0;
2887 }
2888 interruptible_sleep_on(&j->read_q);
2889 if (signal_pending(current)) {
2890 set_current_state(TASK_RUNNING);
2891 remove_wait_queue(&j->read_q, &wait);
2892 j->flags.inread = 0;
2893 return -EINTR;
2894 }
2895 }
2896
2897 remove_wait_queue(&j->read_q, &wait);
2898 set_current_state(TASK_RUNNING);
2899 /* Don't ever copy more than the user asks */
2900 if(j->rec_codec == ALAW)
2901 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2902 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2903 j->read_buffer_ready = 0;
2904 if (i) {
2905 j->flags.inread = 0;
2906 return -EFAULT;
2907 } else {
2908 j->flags.inread = 0;
2909 return min(length, j->read_buffer_size);
2910 }
2911 }
2912
2913 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2914 loff_t * ppos)
2915 {
2916 int pre_retval;
2917 ssize_t read_retval = 0;
2918 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2919
2920 pre_retval = ixj_PreRead(j, 0L);
2921 switch (pre_retval) {
2922 case NORMAL:
2923 read_retval = ixj_read(file_p, buf, length, ppos);
2924 ixj_PostRead(j, 0L);
2925 break;
2926 case NOPOST:
2927 read_retval = ixj_read(file_p, buf, length, ppos);
2928 break;
2929 case POSTONLY:
2930 ixj_PostRead(j, 0L);
2931 break;
2932 default:
2933 read_retval = pre_retval;
2934 }
2935 return read_retval;
2936 }
2937
2938 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2939 {
2940 unsigned long i = *ppos;
2941 IXJ *j = file_p->private_data;
2942
2943 DECLARE_WAITQUEUE(wait, current);
2944
2945 if (j->flags.inwrite)
2946 return -EALREADY;
2947
2948 j->flags.inwrite = 1;
2949
2950 add_wait_queue(&j->write_q, &wait);
2951 set_current_state(TASK_INTERRUPTIBLE);
2952 mb();
2953
2954
2955 while (!j->write_buffers_empty) {
2956 ++j->write_wait;
2957 if (file_p->f_flags & O_NONBLOCK) {
2958 set_current_state(TASK_RUNNING);
2959 remove_wait_queue(&j->write_q, &wait);
2960 j->flags.inwrite = 0;
2961 return -EAGAIN;
2962 }
2963 if (!ixj_hookstate(j)) {
2964 set_current_state(TASK_RUNNING);
2965 remove_wait_queue(&j->write_q, &wait);
2966 j->flags.inwrite = 0;
2967 return 0;
2968 }
2969 interruptible_sleep_on(&j->write_q);
2970 if (signal_pending(current)) {
2971 set_current_state(TASK_RUNNING);
2972 remove_wait_queue(&j->write_q, &wait);
2973 j->flags.inwrite = 0;
2974 return -EINTR;
2975 }
2976 }
2977 set_current_state(TASK_RUNNING);
2978 remove_wait_queue(&j->write_q, &wait);
2979 if (j->write_buffer_wp + count >= j->write_buffer_end)
2980 j->write_buffer_wp = j->write_buffer;
2981 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2982 if (i) {
2983 j->flags.inwrite = 0;
2984 return -EFAULT;
2985 }
2986 if(j->play_codec == ALAW)
2987 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2988 j->flags.inwrite = 0;
2989 return min(count, j->write_buffer_size);
2990 }
2991
2992 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2993 {
2994 int pre_retval;
2995 ssize_t write_retval = 0;
2996
2997 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2998
2999 pre_retval = ixj_PreWrite(j, 0L);
3000 switch (pre_retval) {
3001 case NORMAL:
3002 write_retval = ixj_write(file_p, buf, count, ppos);
3003 if (write_retval > 0) {
3004 ixj_PostWrite(j, 0L);
3005 j->write_buffer_wp += write_retval;
3006 j->write_buffers_empty--;
3007 }
3008 break;
3009 case NOPOST:
3010 write_retval = ixj_write(file_p, buf, count, ppos);
3011 if (write_retval > 0) {
3012 j->write_buffer_wp += write_retval;
3013 j->write_buffers_empty--;
3014 }
3015 break;
3016 case POSTONLY:
3017 ixj_PostWrite(j, 0L);
3018 break;
3019 default:
3020 write_retval = pre_retval;
3021 }
3022 return write_retval;
3023 }
3024
3025 static void ixj_read_frame(IXJ *j)
3026 {
3027 int cnt, dly;
3028
3029 if (j->read_buffer) {
3030 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3031 if (!(cnt % 16) && !IsRxReady(j)) {
3032 dly = 0;
3033 while (!IsRxReady(j)) {
3034 if (dly++ > 5) {
3035 dly = 0;
3036 break;
3037 }
3038 udelay(10);
3039 }
3040 }
3041 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
3042 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3043 inb_p(j->DSPbase + 0x0E);
3044 inb_p(j->DSPbase + 0x0F);
3045 }
3046 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
3047 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
3048 }
3049 ++j->framesread;
3050 if (j->intercom != -1) {
3051 if (IsTxReady(get_ixj(j->intercom))) {
3052 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
3053 if (!(cnt % 16) && !IsTxReady(j)) {
3054 dly = 0;
3055 while (!IsTxReady(j)) {
3056 if (dly++ > 5) {
3057 dly = 0;
3058 break;
3059 }
3060 udelay(10);
3061 }
3062 }
3063 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
3064 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
3065 }
3066 get_ixj(j->intercom)->frameswritten++;
3067 }
3068 } else {
3069 j->read_buffer_ready = 1;
3070 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
3071
3072 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3073
3074 if(j->ixj_signals[SIG_READ_READY])
3075 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
3076 }
3077 }
3078 }
3079
3080 static short fsk[][6][20] =
3081 {
3082 {
3083 {
3084 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
3085 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
3086 },
3087 {
3088 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
3089 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
3090 },
3091 {
3092 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
3093 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
3094 },
3095 {
3096 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
3097 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
3098 },
3099 {
3100 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3101 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3102 },
3103 {
3104 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3105 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3106 }
3107 },
3108 {
3109 {
3110 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3111 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3112 },
3113 {
3114 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3115 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3116 },
3117 {
3118 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3119 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3120 },
3121 {
3122 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3123 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3124 },
3125 {
3126 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3127 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3128 },
3129 {
3130 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3131 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3132 }
3133 }
3134 };
3135
3136
3137 static void ixj_write_cid_bit(IXJ *j, int bit)
3138 {
3139 while (j->fskcnt < 20) {
3140 if(j->fskdcnt < (j->fsksize - 1))
3141 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3142
3143 j->fskcnt += 3;
3144 }
3145 j->fskcnt %= 20;
3146
3147 if (!bit)
3148 j->fskz++;
3149 if (j->fskz >= 6)
3150 j->fskz = 0;
3151
3152 }
3153
3154 static void ixj_write_cid_byte(IXJ *j, char byte)
3155 {
3156 IXJ_CBYTE cb;
3157
3158 cb.cbyte = byte;
3159 ixj_write_cid_bit(j, 0);
3160 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3161 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3162 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3163 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3164 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3165 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3166 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3167 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3168 ixj_write_cid_bit(j, 1);
3169 }
3170
3171 static void ixj_write_cid_seize(IXJ *j)
3172 {
3173 int cnt;
3174
3175 for (cnt = 0; cnt < 150; cnt++) {
3176 ixj_write_cid_bit(j, 0);
3177 ixj_write_cid_bit(j, 1);
3178 }
3179 for (cnt = 0; cnt < 180; cnt++) {
3180 ixj_write_cid_bit(j, 1);
3181 }
3182 }
3183
3184 static void ixj_write_cidcw_seize(IXJ *j)
3185 {
3186 int cnt;
3187
3188 for (cnt = 0; cnt < 80; cnt++) {
3189 ixj_write_cid_bit(j, 1);
3190 }
3191 }
3192
3193 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3194 {
3195 int cnt;
3196
3197 for (cnt = 0; cnt < strlen(s); cnt++) {
3198 ixj_write_cid_byte(j, s[cnt]);
3199 checksum = (checksum + s[cnt]);
3200 }
3201 return checksum;
3202 }
3203
3204 static void ixj_pad_fsk(IXJ *j, int pad)
3205 {
3206 int cnt;
3207
3208 for (cnt = 0; cnt < pad; cnt++) {
3209 if(j->fskdcnt < (j->fsksize - 1))
3210 j->fskdata[j->fskdcnt++] = 0x0000;
3211 }
3212 for (cnt = 0; cnt < 720; cnt++) {
3213 if(j->fskdcnt < (j->fsksize - 1))
3214 j->fskdata[j->fskdcnt++] = 0x0000;
3215 }
3216 }
3217
3218 static void ixj_pre_cid(IXJ *j)
3219 {
3220 j->cid_play_codec = j->play_codec;
3221 j->cid_play_frame_size = j->play_frame_size;
3222 j->cid_play_volume = get_play_volume(j);
3223 j->cid_play_flag = j->flags.playing;
3224
3225 j->cid_rec_codec = j->rec_codec;
3226 j->cid_rec_volume = get_rec_volume(j);
3227 j->cid_rec_flag = j->flags.recording;
3228
3229 j->cid_play_aec_level = j->aec_level;
3230
3231 switch(j->baseframe.low) {
3232 case 0xA0:
3233 j->cid_base_frame_size = 20;
3234 break;
3235 case 0x50:
3236 j->cid_base_frame_size = 10;
3237 break;
3238 case 0xF0:
3239 j->cid_base_frame_size = 30;
3240 break;
3241 }
3242
3243 ixj_play_stop(j);
3244 ixj_cpt_stop(j);
3245
3246 j->flags.cidplay = 1;
3247
3248 set_base_frame(j, 30);
3249 set_play_codec(j, LINEAR16);
3250 set_play_volume(j, 0x1B);
3251 ixj_play_start(j);
3252 }
3253
3254 static void ixj_post_cid(IXJ *j)
3255 {
3256 ixj_play_stop(j);
3257
3258 if(j->cidsize > 5000) {
3259 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3260 }
3261 j->flags.cidplay = 0;
3262 if(ixjdebug & 0x0200) {
3263 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3264 }
3265
3266 ixj_fsk_free(j);
3267
3268 j->fskdcnt = 0;
3269 set_base_frame(j, j->cid_base_frame_size);
3270 set_play_codec(j, j->cid_play_codec);
3271 ixj_aec_start(j, j->cid_play_aec_level);
3272 set_play_volume(j, j->cid_play_volume);
3273
3274 set_rec_codec(j, j->cid_rec_codec);
3275 set_rec_volume(j, j->cid_rec_volume);
3276
3277 if(j->cid_rec_flag)
3278 ixj_record_start(j);
3279
3280 if(j->cid_play_flag)
3281 ixj_play_start(j);
3282
3283 if(j->cid_play_flag) {
3284 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3285 }
3286 }
3287
3288 static void ixj_write_cid(IXJ *j)
3289 {
3290 char sdmf1[50];
3291 char sdmf2[50];
3292 char sdmf3[80];
3293 char mdmflen, len1, len2, len3;
3294 int pad;
3295
3296 int checksum = 0;
3297
3298 if (j->dsp.low == 0x20 || j->flags.cidplay)
3299 return;
3300
3301 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3302 j->cidsize = j->cidcnt = 0;
3303
3304 ixj_fsk_alloc(j);
3305
3306 strcpy(sdmf1, j->cid_send.month);
3307 strcat(sdmf1, j->cid_send.day);
3308 strcat(sdmf1, j->cid_send.hour);
3309 strcat(sdmf1, j->cid_send.min);
3310 strcpy(sdmf2, j->cid_send.number);
3311 strcpy(sdmf3, j->cid_send.name);
3312
3313 len1 = strlen(sdmf1);
3314 len2 = strlen(sdmf2);
3315 len3 = strlen(sdmf3);
3316 mdmflen = len1 + len2 + len3 + 6;
3317
3318 while(1){
3319 ixj_write_cid_seize(j);
3320
3321 ixj_write_cid_byte(j, 0x80);
3322 checksum = 0x80;
3323 ixj_write_cid_byte(j, mdmflen);
3324 checksum = checksum + mdmflen;
3325
3326 ixj_write_cid_byte(j, 0x01);
3327 checksum = checksum + 0x01;
3328 ixj_write_cid_byte(j, len1);
3329 checksum = checksum + len1;
3330 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3331 if(ixj_hookstate(j) & 1)
3332 break;
3333
3334 ixj_write_cid_byte(j, 0x02);
3335 checksum = checksum + 0x02;
3336 ixj_write_cid_byte(j, len2);
3337 checksum = checksum + len2;
3338 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3339 if(ixj_hookstate(j) & 1)
3340 break;
3341
3342 ixj_write_cid_byte(j, 0x07);
3343 checksum = checksum + 0x07;
3344 ixj_write_cid_byte(j, len3);
3345 checksum = checksum + len3;
3346 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3347 if(ixj_hookstate(j) & 1)
3348 break;
3349
3350 checksum %= 256;
3351 checksum ^= 0xFF;
3352 checksum += 1;
3353
3354 ixj_write_cid_byte(j, (char) checksum);
3355
3356 pad = j->fskdcnt % 240;
3357 if (pad) {
3358 pad = 240 - pad;
3359 }
3360 ixj_pad_fsk(j, pad);
3361 break;
3362 }
3363
3364 ixj_write_frame(j);
3365 }
3366
3367 static void ixj_write_cidcw(IXJ *j)
3368 {
3369 IXJ_TONE ti;
3370
3371 char sdmf1[50];
3372 char sdmf2[50];
3373 char sdmf3[80];
3374 char mdmflen, len1, len2, len3;
3375 int pad;
3376
3377 int checksum = 0;
3378
3379 if (j->dsp.low == 0x20 || j->flags.cidplay)
3380 return;
3381
3382 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3383 j->cidsize = j->cidcnt = 0;
3384
3385 ixj_fsk_alloc(j);
3386
3387 j->flags.cidcw_ack = 0;
3388
3389 ti.tone_index = 23;
3390 ti.gain0 = 1;
3391 ti.freq0 = hz440;
3392 ti.gain1 = 0;
3393 ti.freq1 = 0;
3394 ixj_init_tone(j, &ti);
3395
3396 ixj_set_tone_on(1500, j);
3397 ixj_set_tone_off(32, j);
3398 if(ixjdebug & 0x0200) {
3399 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3400 }
3401 ixj_play_tone(j, 23);
3402
3403 clear_bit(j->board, &j->busyflags);
3404 while(j->tone_state) {
3405 set_current_state(TASK_INTERRUPTIBLE);
3406 schedule_timeout(1);
3407 }
3408 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3409 set_current_state(TASK_INTERRUPTIBLE);
3410 schedule_timeout(1);
3411 }
3412 if(ixjdebug & 0x0200) {
3413 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3414 }
3415
3416 ti.tone_index = 24;
3417 ti.gain0 = 1;
3418 ti.freq0 = hz2130;
3419 ti.gain1 = 0;
3420 ti.freq1 = hz2750;
3421 ixj_init_tone(j, &ti);
3422
3423 ixj_set_tone_off(10, j);
3424 ixj_set_tone_on(600, j);
3425 if(ixjdebug & 0x0200) {
3426 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3427 }
3428 ixj_play_tone(j, 24);
3429
3430 clear_bit(j->board, &j->busyflags);
3431 while(j->tone_state) {
3432 set_current_state(TASK_INTERRUPTIBLE);
3433 schedule_timeout(1);
3434 }
3435 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3436 set_current_state(TASK_INTERRUPTIBLE);
3437 schedule_timeout(1);
3438 }
3439 if(ixjdebug & 0x0200) {
3440 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3441 }
3442
3443 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3444
3445 clear_bit(j->board, &j->busyflags);
3446 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3447 set_current_state(TASK_INTERRUPTIBLE);
3448 schedule_timeout(1);
3449 }
3450 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3451 set_current_state(TASK_INTERRUPTIBLE);
3452 schedule_timeout(1);
3453 }
3454 j->cidcw_wait = 0;
3455 if(!j->flags.cidcw_ack) {
3456 if(ixjdebug & 0x0200) {
3457 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3458 }
3459 ixj_post_cid(j);
3460 if(j->cid_play_flag) {
3461 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3462 }
3463 return;
3464 } else {
3465 ixj_pre_cid(j);
3466 }
3467 j->flags.cidcw_ack = 0;
3468 strcpy(sdmf1, j->cid_send.month);
3469 strcat(sdmf1, j->cid_send.day);
3470 strcat(sdmf1, j->cid_send.hour);
3471 strcat(sdmf1, j->cid_send.min);
3472 strcpy(sdmf2, j->cid_send.number);
3473 strcpy(sdmf3, j->cid_send.name);
3474
3475 len1 = strlen(sdmf1);
3476 len2 = strlen(sdmf2);
3477 len3 = strlen(sdmf3);
3478 mdmflen = len1 + len2 + len3 + 6;
3479
3480 ixj_write_cidcw_seize(j);
3481
3482 ixj_write_cid_byte(j, 0x80);
3483 checksum = 0x80;
3484 ixj_write_cid_byte(j, mdmflen);
3485 checksum = checksum + mdmflen;
3486
3487 ixj_write_cid_byte(j, 0x01);
3488 checksum = checksum + 0x01;
3489 ixj_write_cid_byte(j, len1);
3490 checksum = checksum + len1;
3491 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3492
3493 ixj_write_cid_byte(j, 0x02);
3494 checksum = checksum + 0x02;
3495 ixj_write_cid_byte(j, len2);
3496 checksum = checksum + len2;
3497 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3498
3499 ixj_write_cid_byte(j, 0x07);
3500 checksum = checksum + 0x07;
3501 ixj_write_cid_byte(j, len3);
3502 checksum = checksum + len3;
3503 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3504
3505 checksum %= 256;
3506 checksum ^= 0xFF;
3507 checksum += 1;
3508
3509 ixj_write_cid_byte(j, (char) checksum);
3510
3511 pad = j->fskdcnt % 240;
3512 if (pad) {
3513 pad = 240 - pad;
3514 }
3515 ixj_pad_fsk(j, pad);
3516 if(ixjdebug & 0x0200) {
3517 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3518 }
3519 }
3520
3521 static void ixj_write_vmwi(IXJ *j, int msg)
3522 {
3523 char mdmflen;
3524 int pad;
3525
3526 int checksum = 0;
3527
3528 if (j->dsp.low == 0x20 || j->flags.cidplay)
3529 return;
3530
3531 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3532 j->cidsize = j->cidcnt = 0;
3533
3534 ixj_fsk_alloc(j);
3535
3536 mdmflen = 3;
3537
3538 if (j->port == PORT_POTS)
3539 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3540
3541 ixj_write_cid_seize(j);
3542
3543 ixj_write_cid_byte(j, 0x82);
3544 checksum = 0x82;
3545 ixj_write_cid_byte(j, mdmflen);
3546 checksum = checksum + mdmflen;
3547
3548 ixj_write_cid_byte(j, 0x0B);
3549 checksum = checksum + 0x0B;
3550 ixj_write_cid_byte(j, 1);
3551 checksum = checksum + 1;
3552
3553 if(msg) {
3554 ixj_write_cid_byte(j, 0xFF);
3555 checksum = checksum + 0xFF;
3556 }
3557 else {
3558 ixj_write_cid_byte(j, 0x00);
3559 checksum = checksum + 0x00;
3560 }
3561
3562 checksum %= 256;
3563 checksum ^= 0xFF;
3564 checksum += 1;
3565
3566 ixj_write_cid_byte(j, (char) checksum);
3567
3568 pad = j->fskdcnt % 240;
3569 if (pad) {
3570 pad = 240 - pad;
3571 }
3572 ixj_pad_fsk(j, pad);
3573 }
3574
3575 static void ixj_write_frame(IXJ *j)
3576 {
3577 int cnt, frame_count, dly;
3578 IXJ_WORD dat;
3579 BYTES blankword;
3580
3581 frame_count = 0;
3582 if(j->flags.cidplay) {
3583 for(cnt = 0; cnt < 480; cnt++) {
3584 if (!(cnt % 16) && !IsTxReady(j)) {
3585 dly = 0;
3586 while (!IsTxReady(j)) {
3587 if (dly++ > 5) {
3588 dly = 0;
3589 break;
3590 }
3591 udelay(10);
3592 }
3593 }
3594 dat.word = j->fskdata[j->cidcnt++];
3595 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3596 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3597 cnt++;
3598 }
3599 if(j->cidcnt >= j->fskdcnt) {
3600 ixj_post_cid(j);
3601 }
3602 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3603 and there is real audio data in the buffer, we need to throw it away because
3604 we just used it's time slot */
3605 if (j->write_buffer_rp > j->write_buffer_wp) {
3606 j->write_buffer_rp += j->cid_play_frame_size * 2;
3607 if (j->write_buffer_rp >= j->write_buffer_end) {
3608 j->write_buffer_rp = j->write_buffer;
3609 }
3610 j->write_buffers_empty++;
3611 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3612
3613 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3614 }
3615 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3616 if (j->write_buffer_wp > j->write_buffer_rp) {
3617 frame_count =
3618 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3619 }
3620 if (j->write_buffer_rp > j->write_buffer_wp) {
3621 frame_count =
3622 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3623 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3624 }
3625 if (frame_count >= 1) {
3626 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3627 switch (j->play_mode) {
3628 case PLAYBACK_MODE_ULAW:
3629 case PLAYBACK_MODE_ALAW:
3630 blankword.low = blankword.high = 0xFF;
3631 break;
3632 case PLAYBACK_MODE_8LINEAR:
3633 case PLAYBACK_MODE_16LINEAR:
3634 blankword.low = blankword.high = 0x00;
3635 break;
3636 case PLAYBACK_MODE_8LINEAR_WSS:
3637 blankword.low = blankword.high = 0x80;
3638 break;
3639 }
3640 for (cnt = 0; cnt < 16; cnt++) {
3641 if (!(cnt % 16) && !IsTxReady(j)) {
3642 dly = 0;
3643 while (!IsTxReady(j)) {
3644 if (dly++ > 5) {
3645 dly = 0;
3646 break;
3647 }
3648 udelay(10);
3649 }
3650 }
3651 outb_p((blankword.low), j->DSPbase + 0x0C);
3652 outb_p((blankword.high), j->DSPbase + 0x0D);
3653 }
3654 j->flags.play_first_frame = 0;
3655 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3656 for (cnt = 0; cnt < 24; cnt++) {
3657 if(cnt == 12) {
3658 blankword.low = 0x02;
3659 blankword.high = 0x00;
3660 }
3661 else {
3662 blankword.low = blankword.high = 0x00;
3663 }
3664 if (!(cnt % 16) && !IsTxReady(j)) {
3665 dly = 0;
3666 while (!IsTxReady(j)) {
3667 if (dly++ > 5) {
3668 dly = 0;
3669 break;
3670 }
3671 udelay(10);
3672 }
3673 }
3674 outb_p((blankword.low), j->DSPbase + 0x0C);
3675 outb_p((blankword.high), j->DSPbase + 0x0D);
3676 }
3677 j->flags.play_first_frame = 0;
3678 }
3679 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3680 if (!(cnt % 16) && !IsTxReady(j)) {
3681 dly = 0;
3682 while (!IsTxReady(j)) {
3683 if (dly++ > 5) {
3684 dly = 0;
3685 break;
3686 }
3687 udelay(10);
3688 }
3689 }
3690 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3691 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3692 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3693 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3694 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3695 j->write_buffer_rp + cnt + 9 == 0) {
3696 /* someone is trying to write silence lets make this a type 0 frame. */
3697 outb_p(0x00, j->DSPbase + 0x0C);
3698 outb_p(0x00, j->DSPbase + 0x0D);
3699 } else {
3700 /* so all other frames are type 1. */
3701 outb_p(0x01, j->DSPbase + 0x0C);
3702 outb_p(0x00, j->DSPbase + 0x0D);
3703 }
3704 }
3705 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3706 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3707 *(j->write_buffer_rp + cnt) = 0;
3708 *(j->write_buffer_rp + cnt + 1) = 0;
3709 }
3710 j->write_buffer_rp += j->play_frame_size * 2;
3711 if (j->write_buffer_rp >= j->write_buffer_end) {
3712 j->write_buffer_rp = j->write_buffer;
3713 }
3714 j->write_buffers_empty++;
3715 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3716
3717 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3718
3719 ++j->frameswritten;
3720 }
3721 } else {
3722 j->drybuffer++;
3723 }
3724 if(j->ixj_signals[SIG_WRITE_READY]) {
3725 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3726 }
3727 }
3728
3729 static int idle(IXJ *j)
3730 {
3731 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3732
3733 return 0;
3734
3735 if (j->ssr.high || j->ssr.low) {
3736 return 0;
3737 } else {
3738 j->play_mode = -1;
3739 j->flags.playing = 0;
3740 j->rec_mode = -1;
3741 j->flags.recording = 0;
3742 return 1;
3743 }
3744 }
3745
3746 static int set_base_frame(IXJ *j, int size)
3747 {
3748 unsigned short cmd;
3749 int cnt;
3750
3751 idle(j);
3752 j->cid_play_aec_level = j->aec_level;
3753 aec_stop(j);
3754 for (cnt = 0; cnt < 10; cnt++) {
3755 if (idle(j))
3756 break;
3757 }
3758 if (j->ssr.high || j->ssr.low)
3759 return -1;
3760 if (j->dsp.low != 0x20) {
3761 switch (size) {
3762 case 30:
3763 cmd = 0x07F0;
3764 /* Set Base Frame Size to 240 pg9-10 8021 */
3765 break;
3766 case 20:
3767 cmd = 0x07A0;
3768 /* Set Base Frame Size to 160 pg9-10 8021 */
3769 break;
3770 case 10:
3771 cmd = 0x0750;
3772 /* Set Base Frame Size to 80 pg9-10 8021 */
3773 break;
3774 default:
3775 return -1;
3776 }
3777 } else {
3778 if (size == 30)
3779 return size;
3780 else
3781 return -1;
3782 }
3783 if (ixj_WriteDSPCommand(cmd, j)) {
3784 j->baseframe.high = j->baseframe.low = 0xFF;
3785 return -1;
3786 } else {
3787 j->baseframe.high = j->ssr.high;
3788 j->baseframe.low = j->ssr.low;
3789 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3790 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3791 return -1;
3792 }
3793 }
3794 ixj_aec_start(j, j->cid_play_aec_level);
3795 return size;
3796 }
3797
3798 static int set_rec_codec(IXJ *j, int rate)
3799 {
3800 int retval = 0;
3801
3802 j->rec_codec = rate;
3803
3804 switch (rate) {
3805 case G723_63:
3806 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3807 j->rec_frame_size = 12;
3808 j->rec_mode = 0;
3809 } else {
3810 retval = 1;
3811 }
3812 break;
3813 case G723_53:
3814 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3815 j->rec_frame_size = 10;
3816 j->rec_mode = 0;
3817 } else {
3818 retval = 1;
3819 }
3820 break;
3821 case TS85:
3822 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3823 j->rec_frame_size = 16;
3824 j->rec_mode = 0;
3825 } else {
3826 retval = 1;
3827 }
3828 break;
3829 case TS48:
3830 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3831 j->rec_frame_size = 9;
3832 j->rec_mode = 0;
3833 } else {
3834 retval = 1;
3835 }
3836 break;
3837 case TS41:
3838 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3839 j->rec_frame_size = 8;
3840 j->rec_mode = 0;
3841 } else {
3842 retval = 1;
3843 }
3844 break;
3845 case G728:
3846 if (j->dsp.low != 0x20) {
3847 j->rec_frame_size = 48;
3848 j->rec_mode = 0;
3849 } else {
3850 retval = 1;
3851 }
3852 break;
3853 case G729:
3854 if (j->dsp.low != 0x20) {
3855 if (!j->flags.g729_loaded) {
3856 retval = 1;
3857 break;
3858 }
3859 switch (j->baseframe.low) {
3860 case 0xA0:
3861 j->rec_frame_size = 10;
3862 break;
3863 case 0x50:
3864 j->rec_frame_size = 5;
3865 break;
3866 default:
3867 j->rec_frame_size = 15;
3868 break;
3869 }
3870 j->rec_mode = 0;
3871 } else {
3872 retval = 1;
3873 }
3874 break;
3875 case G729B:
3876 if (j->dsp.low != 0x20) {
3877 if (!j->flags.g729_loaded) {
3878 retval = 1;
3879 break;
3880 }
3881 switch (j->baseframe.low) {
3882 case 0xA0:
3883 j->rec_frame_size = 12;
3884 break;
3885 case 0x50:
3886 j->rec_frame_size = 6;
3887 break;
3888 default:
3889 j->rec_frame_size = 18;
3890 break;
3891 }
3892 j->rec_mode = 0;
3893 } else {
3894 retval = 1;
3895 }
3896 break;
3897 case ULAW:
3898 switch (j->baseframe.low) {
3899 case 0xA0:
3900 j->rec_frame_size = 80;
3901 break;
3902 case 0x50:
3903 j->rec_frame_size = 40;
3904 break;
3905 default:
3906 j->rec_frame_size = 120;
3907 break;
3908 }
3909 j->rec_mode = 4;
3910 break;
3911 case ALAW:
3912 switch (j->baseframe.low) {
3913 case 0xA0:
3914 j->rec_frame_size = 80;
3915 break;
3916 case 0x50:
3917 j->rec_frame_size = 40;
3918 break;
3919 default:
3920 j->rec_frame_size = 120;
3921 break;
3922 }
3923 j->rec_mode = 4;
3924 break;
3925 case LINEAR16:
3926 switch (j->baseframe.low) {
3927 case 0xA0:
3928 j->rec_frame_size = 160;
3929 break;
3930 case 0x50:
3931 j->rec_frame_size = 80;
3932 break;
3933 default:
3934 j->rec_frame_size = 240;
3935 break;
3936 }
3937 j->rec_mode = 5;
3938 break;
3939 case LINEAR8:
3940 switch (j->baseframe.low) {
3941 case 0xA0:
3942 j->rec_frame_size = 80;
3943 break;
3944 case 0x50:
3945 j->rec_frame_size = 40;
3946 break;
3947 default:
3948 j->rec_frame_size = 120;
3949 break;
3950 }
3951 j->rec_mode = 6;
3952 break;
3953 case WSS:
3954 switch (j->baseframe.low) {
3955 case 0xA0:
3956 j->rec_frame_size = 80;
3957 break;
3958 case 0x50:
3959 j->rec_frame_size = 40;
3960 break;
3961 default:
3962 j->rec_frame_size = 120;
3963 break;
3964 }
3965 j->rec_mode = 7;
3966 break;
3967 default:
3968 j->rec_frame_size = 0;
3969 j->rec_mode = -1;
3970 if (j->read_buffer) {
3971 kfree(j->read_buffer);
3972 j->read_buffer = NULL;
3973 j->read_buffer_size = 0;
3974 }
3975 retval = 1;
3976 break;
3977 }
3978 return retval;
3979 }
3980
3981 static int ixj_record_start(IXJ *j)
3982 {
3983 unsigned short cmd = 0x0000;
3984
3985 if (j->read_buffer) {
3986 ixj_record_stop(j);
3987 }
3988 j->flags.recording = 1;
3989 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3990
3991 if(ixjdebug & 0x0002)
3992 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3993
3994 if (!j->rec_mode) {
3995 switch (j->rec_codec) {
3996 case G723_63:
3997 cmd = 0x5131;
3998 break;
3999 case G723_53:
4000 cmd = 0x5132;
4001 break;
4002 case TS85:
4003 cmd = 0x5130; /* TrueSpeech 8.5 */
4004
4005 break;
4006 case TS48:
4007 cmd = 0x5133; /* TrueSpeech 4.8 */
4008
4009 break;
4010 case TS41:
4011 cmd = 0x5134; /* TrueSpeech 4.1 */
4012
4013 break;
4014 case G728:
4015 cmd = 0x5135;
4016 break;
4017 case G729:
4018 case G729B:
4019 cmd = 0x5136;
4020 break;
4021 default:
4022 return 1;
4023 }
4024 if (ixj_WriteDSPCommand(cmd, j))
4025 return -1;
4026 }
4027 if (!j->read_buffer) {
4028 if (!j->read_buffer)
4029 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
4030 if (!j->read_buffer) {
4031 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
4032 return -ENOMEM;
4033 }
4034 }
4035 j->read_buffer_size = j->rec_frame_size * 2;
4036
4037 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
4038
4039 return -1;
4040
4041 switch (j->rec_mode) {
4042 case 0:
4043 cmd = 0x1C03; /* Record C1 */
4044
4045 break;
4046 case 4:
4047 if (j->ver.low == 0x12) {
4048 cmd = 0x1E03; /* Record C1 */
4049
4050 } else {
4051 cmd = 0x1E01; /* Record C1 */
4052
4053 }
4054 break;
4055 case 5:
4056 if (j->ver.low == 0x12) {
4057 cmd = 0x1E83; /* Record C1 */
4058
4059 } else {
4060 cmd = 0x1E81; /* Record C1 */
4061
4062 }
4063 break;
4064 case 6:
4065 if (j->ver.low == 0x12) {
4066 cmd = 0x1F03; /* Record C1 */
4067
4068 } else {
4069 cmd = 0x1F01; /* Record C1 */
4070
4071 }
4072 break;
4073 case 7:
4074 if (j->ver.low == 0x12) {
4075 cmd = 0x1F83; /* Record C1 */
4076 } else {
4077 cmd = 0x1F81; /* Record C1 */
4078 }
4079 break;
4080 }
4081 if (ixj_WriteDSPCommand(cmd, j))
4082 return -1;
4083
4084 if (j->flags.playing) {
4085 ixj_aec_start(j, j->aec_level);
4086 }
4087 return 0;
4088 }
4089
4090 static void ixj_record_stop(IXJ *j)
4091 {
4092 if(ixjdebug & 0x0002)
4093 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
4094
4095 if (j->read_buffer) {
4096 kfree(j->read_buffer);
4097 j->read_buffer = NULL;
4098 j->read_buffer_size = 0;
4099 }
4100 if (j->rec_mode > -1) {
4101 ixj_WriteDSPCommand(0x5120, j);
4102 j->rec_mode = -1;
4103 }
4104 j->flags.recording = 0;
4105 }
4106 static void ixj_vad(IXJ *j, int arg)
4107 {
4108 if (arg)
4109 ixj_WriteDSPCommand(0x513F, j);
4110 else
4111 ixj_WriteDSPCommand(0x513E, j);
4112 }
4113
4114 static void set_rec_depth(IXJ *j, int depth)
4115 {
4116 if (depth > 60)
4117 depth = 60;
4118 if (depth < 0)
4119 depth = 0;
4120 ixj_WriteDSPCommand(0x5180 + depth, j);
4121 }
4122
4123 static void set_dtmf_prescale(IXJ *j, int volume)
4124 {
4125 ixj_WriteDSPCommand(0xCF07, j);
4126 ixj_WriteDSPCommand(volume, j);
4127 }
4128
4129 static int get_dtmf_prescale(IXJ *j)
4130 {
4131 ixj_WriteDSPCommand(0xCF05, j);
4132 return j->ssr.high << 8 | j->ssr.low;
4133 }
4134
4135 static void set_rec_volume(IXJ *j, int volume)
4136 {
4137 if(j->aec_level == AEC_AGC) {
4138 if (ixjdebug & 0x0002)
4139 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4140 ixj_WriteDSPCommand(0xCF96, j);
4141 ixj_WriteDSPCommand(volume, j);
4142 } else {
4143 if (ixjdebug & 0x0002)
4144 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4145 ixj_WriteDSPCommand(0xCF03, j);
4146 ixj_WriteDSPCommand(volume, j);
4147 }
4148 }
4149
4150 static int set_rec_volume_linear(IXJ *j, int volume)
4151 {
4152 int newvolume, dsprecmax;
4153
4154 if (ixjdebug & 0x0002)
4155 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4156 if(volume > 100 || volume < 0) {
4157 return -1;
4158 }
4159
4160 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4161 switch (j->cardtype) {
4162 case QTI_PHONEJACK:
4163 dsprecmax = 0x440;
4164 break;
4165 case QTI_LINEJACK:
4166 dsprecmax = 0x180;
4167 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4168 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4169 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4170 break;
4171 case QTI_PHONEJACK_LITE:
4172 dsprecmax = 0x4C0;
4173 break;
4174 case QTI_PHONEJACK_PCI:
4175 dsprecmax = 0x100;
4176 break;
4177 case QTI_PHONECARD:
4178 dsprecmax = 0x400;
4179 break;
4180 default:
4181 return -1;
4182 }
4183 newvolume = (dsprecmax * volume) / 100;
4184 set_rec_volume(j, newvolume);
4185 return 0;
4186 }
4187
4188 static int get_rec_volume(IXJ *j)
4189 {
4190 if(j->aec_level == AEC_AGC) {
4191 if (ixjdebug & 0x0002)
4192 printk(KERN_INFO "Getting AGC Threshold\n");
4193 ixj_WriteDSPCommand(0xCF86, j);
4194 if (ixjdebug & 0x0002)
4195 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4196 return j->ssr.high << 8 | j->ssr.low;
4197 } else {
4198 if (ixjdebug & 0x0002)
4199 printk(KERN_INFO "Getting Record Volume\n");
4200 ixj_WriteDSPCommand(0xCF01, j);
4201 return j->ssr.high << 8 | j->ssr.low;
4202 }
4203 }
4204
4205 static int get_rec_volume_linear(IXJ *j)
4206 {
4207 int volume, newvolume, dsprecmax;
4208
4209 switch (j->cardtype) {
4210 case QTI_PHONEJACK:
4211 dsprecmax = 0x440;
4212 break;
4213 case QTI_LINEJACK:
4214 dsprecmax = 0x180;
4215 break;
4216 case QTI_PHONEJACK_LITE:
4217 dsprecmax = 0x4C0;
4218 break;
4219 case QTI_PHONEJACK_PCI:
4220 dsprecmax = 0x100;
4221 break;
4222 case QTI_PHONECARD:
4223 dsprecmax = 0x400;
4224 break;
4225 default:
4226 return -1;
4227 }
4228 volume = get_rec_volume(j);
4229 newvolume = (volume * 100) / dsprecmax;
4230 if(newvolume > 100)
4231 newvolume = 100;
4232 return newvolume;
4233 }
4234
4235 static int get_rec_level(IXJ *j)
4236 {
4237 int retval;
4238
4239 ixj_WriteDSPCommand(0xCF88, j);
4240
4241 retval = j->ssr.high << 8 | j->ssr.low;
4242 retval = (retval * 256) / 240;
4243 return retval;
4244 }
4245
4246 static void ixj_aec_start(IXJ *j, int level)
4247 {
4248 j->aec_level = level;
4249 if (ixjdebug & 0x0002)
4250 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4251 if (!level) {
4252 aec_stop(j);
4253 } else {
4254 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4255 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4256
4257 ixj_WriteDSPCommand(0x0300, j);
4258 }
4259 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4260
4261 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4262
4263 switch (level) {
4264 case AEC_LOW:
4265 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4266
4267 ixj_WriteDSPCommand(0xE011, j);
4268 ixj_WriteDSPCommand(0xFFFF, j);
4269
4270 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4271 ixj_WriteDSPCommand(0x0000, j); /* to off */
4272
4273 break;
4274
4275 case AEC_MED:
4276 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4277
4278 ixj_WriteDSPCommand(0xE011, j);
4279 ixj_WriteDSPCommand(0x0080, j);
4280
4281 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4282 ixj_WriteDSPCommand(0x0000, j); /* to off */
4283
4284 break;
4285
4286 case AEC_HIGH:
4287 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4288
4289 ixj_WriteDSPCommand(0xE011, j);
4290 ixj_WriteDSPCommand(0x0080, j);
4291
4292 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4293 ixj_WriteDSPCommand(0x0000, j); /* to off */
4294
4295 break;
4296
4297 case AEC_AGC:
4298 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4299 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4300
4301 ixj_WriteDSPCommand(0xE011, j);
4302 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4303
4304 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4305
4306 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4307 ixj_WriteDSPCommand(0x0224, j);
4308 else
4309 ixj_WriteDSPCommand(0x1224, j);
4310
4311 ixj_WriteDSPCommand(0xE014, j);
4312 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4313
4314 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4315
4316 /* Now we can set the AGC initial parameters and turn it on */
4317 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4318 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4319
4320 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4321 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4322
4323 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4324 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4325
4326 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4327 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4328
4329 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4330 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4331
4332 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4333 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4334
4335 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4336 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4337
4338 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4339 ixj_WriteDSPCommand(0x0001, j); /* to on */
4340
4341 break;
4342
4343 case AEC_AUTO:
4344 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4345
4346 ixj_WriteDSPCommand(0xE011, j);
4347 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4348
4349 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4350
4351 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4352 ixj_WriteDSPCommand(0x0224, j);
4353 else
4354 ixj_WriteDSPCommand(0x1224, j);
4355
4356 ixj_WriteDSPCommand(0xE014, j);
4357 ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4358
4359 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4360
4361 break;
4362 }
4363 }
4364 }
4365
4366 static void aec_stop(IXJ *j)
4367 {
4368 j->aec_level = AEC_OFF;
4369 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4370 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4371
4372 ixj_WriteDSPCommand(0x0700, j);
4373 }
4374 if (j->play_mode != -1 && j->rec_mode != -1)
4375 {
4376 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4377 }
4378 }
4379
4380 static int set_play_codec(IXJ *j, int rate)
4381 {
4382 int retval = 0;
4383
4384 j->play_codec = rate;
4385
4386 switch (rate) {
4387 case G723_63:
4388 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4389 j->play_frame_size = 12;
4390 j->play_mode = 0;
4391 } else {
4392 retval = 1;
4393 }
4394 break;
4395 case G723_53:
4396 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4397 j->play_frame_size = 10;
4398 j->play_mode = 0;
4399 } else {
4400 retval = 1;
4401 }
4402 break;
4403 case TS85:
4404 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4405 j->play_frame_size = 16;
4406 j->play_mode = 0;
4407 } else {
4408 retval = 1;
4409 }
4410 break;
4411 case TS48:
4412 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4413 j->play_frame_size = 9;
4414 j->play_mode = 0;
4415 } else {
4416 retval = 1;
4417 }
4418 break;
4419 case TS41:
4420 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4421 j->play_frame_size = 8;
4422 j->play_mode = 0;
4423 } else {
4424 retval = 1;
4425 }
4426 break;
4427 case G728:
4428 if (j->dsp.low != 0x20) {
4429 j->play_frame_size = 48;
4430 j->play_mode = 0;
4431 } else {
4432 retval = 1;
4433 }
4434 break;
4435 case G729:
4436 if (j->dsp.low != 0x20) {
4437 if (!j->flags.g729_loaded) {
4438 retval = 1;
4439 break;
4440 }
4441 switch (j->baseframe.low) {
4442 case 0xA0:
4443 j->play_frame_size = 10;
4444 break;
4445 case 0x50:
4446 j->play_frame_size = 5;
4447 break;
4448 default:
4449 j->play_frame_size = 15;
4450 break;
4451 }
4452 j->play_mode = 0;
4453 } else {
4454 retval = 1;
4455 }
4456 break;
4457 case G729B:
4458 if (j->dsp.low != 0x20) {
4459 if (!j->flags.g729_loaded) {
4460 retval = 1;
4461 break;
4462 }
4463 switch (j->baseframe.low) {
4464 case 0xA0:
4465 j->play_frame_size = 12;
4466 break;
4467 case 0x50:
4468 j->play_frame_size = 6;
4469 break;
4470 default:
4471 j->play_frame_size = 18;
4472 break;
4473 }
4474 j->play_mode = 0;
4475 } else {
4476 retval = 1;
4477 }
4478 break;
4479 case ULAW:
4480 switch (j->baseframe.low) {
4481 case 0xA0:
4482 j->play_frame_size = 80;
4483 break;
4484 case 0x50:
4485 j->play_frame_size = 40;
4486 break;
4487 default:
4488 j->play_frame_size = 120;
4489 break;
4490 }
4491 j->play_mode = 2;
4492 break;
4493 case ALAW:
4494 switch (j->baseframe.low) {
4495 case 0xA0:
4496 j->play_frame_size = 80;
4497 break;
4498 case 0x50:
4499 j->play_frame_size = 40;
4500 break;
4501 default:
4502 j->play_frame_size = 120;
4503 break;
4504 }
4505 j->play_mode = 2;
4506 break;
4507 case LINEAR16:
4508 switch (j->baseframe.low) {
4509 case 0xA0:
4510 j->play_frame_size = 160;
4511 break;
4512 case 0x50:
4513 j->play_frame_size = 80;
4514 break;
4515 default:
4516 j->play_frame_size = 240;
4517 break;
4518 }
4519 j->play_mode = 6;
4520 break;
4521 case LINEAR8:
4522 switch (j->baseframe.low) {
4523 case 0xA0:
4524 j->play_frame_size = 80;
4525 break;
4526 case 0x50:
4527 j->play_frame_size = 40;
4528 break;
4529 default:
4530 j->play_frame_size = 120;
4531 break;
4532 }
4533 j->play_mode = 4;
4534 break;
4535 case WSS:
4536 switch (j->baseframe.low) {
4537 case 0xA0:
4538 j->play_frame_size = 80;
4539 break;
4540 case 0x50:
4541 j->play_frame_size = 40;
4542 break;
4543 default:
4544 j->play_frame_size = 120;
4545 break;
4546 }
4547 j->play_mode = 5;
4548 break;
4549 default:
4550 j->play_frame_size = 0;
4551 j->play_mode = -1;
4552 if (j->write_buffer) {
4553 kfree(j->write_buffer);
4554 j->write_buffer = NULL;
4555 j->write_buffer_size = 0;
4556 }
4557 retval = 1;
4558 break;
4559 }
4560 return retval;
4561 }
4562
4563 static int ixj_play_start(IXJ *j)
4564 {
4565 unsigned short cmd = 0x0000;
4566
4567 if (j->write_buffer) {
4568 ixj_play_stop(j);
4569 }
4570
4571 if(ixjdebug & 0x0002)
4572 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4573
4574 j->flags.playing = 1;
4575 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4576
4577 j->flags.play_first_frame = 1;
4578 j->drybuffer = 0;
4579
4580 if (!j->play_mode) {
4581 switch (j->play_codec) {
4582 case G723_63:
4583 cmd = 0x5231;
4584 break;
4585 case G723_53:
4586 cmd = 0x5232;
4587 break;
4588 case TS85:
4589 cmd = 0x5230; /* TrueSpeech 8.5 */
4590
4591 break;
4592 case TS48:
4593 cmd = 0x5233; /* TrueSpeech 4.8 */
4594
4595 break;
4596 case TS41:
4597 cmd = 0x5234; /* TrueSpeech 4.1 */
4598
4599 break;
4600 case G728:
4601 cmd = 0x5235;
4602 break;
4603 case G729:
4604 case G729B:
4605 cmd = 0x5236;
4606 break;
4607 default:
4608 return 1;
4609 }
4610 if (ixj_WriteDSPCommand(cmd, j))
4611 return -1;
4612 }
4613 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4614 if (!j->write_buffer) {
4615 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4616 return -ENOMEM;
4617 }
4618 /* j->write_buffers_empty = 2; */
4619 j->write_buffers_empty = 1;
4620 j->write_buffer_size = j->play_frame_size * 2;
4621 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4622 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4623
4624 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4625
4626 return -1;
4627
4628 switch (j->play_mode) {
4629 case 0:
4630 cmd = 0x2C03;
4631 break;
4632 case 2:
4633 if (j->ver.low == 0x12) {
4634 cmd = 0x2C23;
4635 } else {
4636 cmd = 0x2C21;
4637 }
4638 break;
4639 case 4:
4640 if (j->ver.low == 0x12) {
4641 cmd = 0x2C43;
4642 } else {
4643 cmd = 0x2C41;
4644 }
4645 break;
4646 case 5:
4647 if (j->ver.low == 0x12) {
4648 cmd = 0x2C53;
4649 } else {
4650 cmd = 0x2C51;
4651 }
4652 break;
4653 case 6:
4654 if (j->ver.low == 0x12) {
4655 cmd = 0x2C63;
4656 } else {
4657 cmd = 0x2C61;
4658 }
4659 break;
4660 }
4661 if (ixj_WriteDSPCommand(cmd, j))
4662 return -1;
4663
4664 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4665 return -1;
4666
4667 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4668 return -1;
4669
4670 if (j->flags.recording) {
4671 ixj_aec_start(j, j->aec_level);
4672 }
4673
4674 return 0;
4675 }
4676
4677 static void ixj_play_stop(IXJ *j)
4678 {
4679 if(ixjdebug & 0x0002)
4680 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4681
4682 if (j->write_buffer) {
4683 kfree(j->write_buffer);
4684 j->write_buffer = NULL;
4685 j->write_buffer_size = 0;
4686 }
4687 if (j->play_mode > -1) {
4688 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4689
4690 j->play_mode = -1;
4691 }
4692 j->flags.playing = 0;
4693 }
4694
4695 static inline int get_play_level(IXJ *j)
4696 {
4697 int retval;
4698
4699 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4700 return j->ssr.high << 8 | j->ssr.low;
4701 retval = j->ssr.high << 8 | j->ssr.low;
4702 retval = (retval * 256) / 240;
4703 return retval;
4704 }
4705
4706 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4707 {
4708 unsigned int mask = 0;
4709
4710 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4711
4712 poll_wait(file_p, &(j->poll_q), wait);
4713 if (j->read_buffer_ready > 0)
4714 mask |= POLLIN | POLLRDNORM; /* readable */
4715 if (j->write_buffers_empty > 0)
4716 mask |= POLLOUT | POLLWRNORM; /* writable */
4717 if (j->ex.bytes)
4718 mask |= POLLPRI;
4719 return mask;
4720 }
4721
4722 static int ixj_play_tone(IXJ *j, char tone)
4723 {
4724 if (!j->tone_state) {
4725 if(ixjdebug & 0x0002) {
4726 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4727 }
4728 if (j->dsp.low == 0x20) {
4729 idle(j);
4730 }
4731 j->tone_start_jif = jiffies;
4732
4733 j->tone_state = 1;
4734 }
4735
4736 j->tone_index = tone;
4737 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4738 return -1;
4739
4740 return 0;
4741 }
4742
4743 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4744 {
4745 j->tone_on_time = arg;
4746
4747 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4748
4749 return -1;
4750
4751 if (ixj_WriteDSPCommand(arg, j))
4752 return -1;
4753
4754 return 0;
4755 }
4756
4757 static int SCI_WaitHighSCI(IXJ *j)
4758 {
4759 int cnt;
4760
4761 j->pld_scrr.byte = inb_p(j->XILINXbase);
4762 if (!j->pld_scrr.bits.sci) {
4763 for (cnt = 0; cnt < 10; cnt++) {
4764 udelay(32);
4765 j->pld_scrr.byte = inb_p(j->XILINXbase);
4766
4767 if ((j->pld_scrr.bits.sci))
4768 return 1;
4769 }
4770 if (ixjdebug & 0x0001)
4771 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4772 return 0;
4773 } else
4774 return 1;
4775 }
4776
4777 static int SCI_WaitLowSCI(IXJ *j)
4778 {
4779 int cnt;
4780
4781 j->pld_scrr.byte = inb_p(j->XILINXbase);
4782 if (j->pld_scrr.bits.sci) {
4783 for (cnt = 0; cnt < 10; cnt++) {
4784 udelay(32);
4785 j->pld_scrr.byte = inb_p(j->XILINXbase);
4786
4787 if (!(j->pld_scrr.bits.sci))
4788 return 1;
4789 }
4790 if (ixjdebug & 0x0001)
4791 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4792 return 0;
4793 } else
4794 return 1;
4795 }
4796
4797 static int SCI_Control(IXJ *j, int control)
4798 {
4799 switch (control) {
4800 case SCI_End:
4801 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4802
4803 j->pld_scrw.bits.c1 = 0; /* to no selection */
4804
4805 break;
4806 case SCI_Enable_DAA:
4807 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4808
4809 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4810
4811 break;
4812 case SCI_Enable_Mixer:
4813 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4814
4815 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4816
4817 break;
4818 case SCI_Enable_EEPROM:
4819 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4820
4821 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4822
4823 break;
4824 default:
4825 return 0;
4826 break;
4827 }
4828 outb_p(j->pld_scrw.byte, j->XILINXbase);
4829
4830 switch (control) {
4831 case SCI_End:
4832 return 1;
4833 break;
4834 case SCI_Enable_DAA:
4835 case SCI_Enable_Mixer:
4836 case SCI_Enable_EEPROM:
4837 if (!SCI_WaitHighSCI(j))
4838 return 0;
4839 break;
4840 default:
4841 return 0;
4842 break;
4843 }
4844 return 1;
4845 }
4846
4847 static int SCI_Prepare(IXJ *j)
4848 {
4849 if (!SCI_Control(j, SCI_End))
4850 return 0;
4851
4852 if (!SCI_WaitLowSCI(j))
4853 return 0;
4854
4855 return 1;
4856 }
4857
4858 static int ixj_get_mixer(long val, IXJ *j)
4859 {
4860 int reg = (val & 0x1F00) >> 8;
4861 return j->mix.vol[reg];
4862 }
4863
4864 static int ixj_mixer(long val, IXJ *j)
4865 {
4866 BYTES bytes;
4867
4868 bytes.high = (val & 0x1F00) >> 8;
4869 bytes.low = val & 0x00FF;
4870
4871 /* save mixer value so we can get back later on */
4872 j->mix.vol[bytes.high] = bytes.low;
4873
4874 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4875
4876 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4877
4878 SCI_Control(j, SCI_Enable_Mixer);
4879
4880 SCI_Control(j, SCI_End);
4881
4882 return 0;
4883 }
4884
4885 static int daa_load(BYTES * p_bytes, IXJ *j)
4886 {
4887 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4888 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4889 if (!SCI_Control(j, SCI_Enable_DAA))
4890 return 0;
4891 else
4892 return 1;
4893 }
4894
4895 static int ixj_daa_cr4(IXJ *j, char reg)
4896 {
4897 BYTES bytes;
4898
4899 switch (j->daa_mode) {
4900 case SOP_PU_SLEEP:
4901 bytes.high = 0x14;
4902 break;
4903 case SOP_PU_RINGING:
4904 bytes.high = 0x54;
4905 break;
4906 case SOP_PU_CONVERSATION:
4907 bytes.high = 0x94;
4908 break;
4909 case SOP_PU_PULSEDIALING:
4910 bytes.high = 0xD4;
4911 break;
4912 }
4913
4914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4915
4916 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4917 case 0:
4918 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4919 break;
4920 case 1:
4921 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4922 break;
4923 case 2:
4924 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4925 break;
4926 case 3:
4927 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4928 break;
4929 }
4930
4931 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4932
4933 if (!daa_load(&bytes, j))
4934 return 0;
4935
4936 if (!SCI_Prepare(j))
4937 return 0;
4938
4939 return 1;
4940 }
4941
4942 static char daa_int_read(IXJ *j)
4943 {
4944 BYTES bytes;
4945
4946 if (!SCI_Prepare(j))
4947 return 0;
4948
4949 bytes.high = 0x38;
4950 bytes.low = 0x00;
4951 outb_p(bytes.high, j->XILINXbase + 0x03);
4952 outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954 if (!SCI_Control(j, SCI_Enable_DAA))
4955 return 0;
4956
4957 bytes.high = inb_p(j->XILINXbase + 0x03);
4958 bytes.low = inb_p(j->XILINXbase + 0x02);
4959 if (bytes.low != ALISDAA_ID_BYTE) {
4960 if (ixjdebug & 0x0001)
4961 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4962 return 0;
4963 }
4964 if (!SCI_Control(j, SCI_Enable_DAA))
4965 return 0;
4966 if (!SCI_Control(j, SCI_End))
4967 return 0;
4968
4969 bytes.high = inb_p(j->XILINXbase + 0x03);
4970 bytes.low = inb_p(j->XILINXbase + 0x02);
4971
4972 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4973
4974 return 1;
4975 }
4976
4977 static char daa_CR_read(IXJ *j, int cr)
4978 {
4979 IXJ_WORD wdata;
4980 BYTES bytes;
4981
4982 if (!SCI_Prepare(j))
4983 return 0;
4984
4985 switch (j->daa_mode) {
4986 case SOP_PU_SLEEP:
4987 bytes.high = 0x30 + cr;
4988 break;
4989 case SOP_PU_RINGING:
4990 bytes.high = 0x70 + cr;
4991 break;
4992 case SOP_PU_CONVERSATION:
4993 bytes.high = 0xB0 + cr;
4994 break;
4995 case SOP_PU_PULSEDIALING:
4996 bytes.high = 0xF0 + cr;
4997 break;
4998 }
4999
5000 bytes.low = 0x00;
5001
5002 outb_p(bytes.high, j->XILINXbase + 0x03);
5003 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005 if (!SCI_Control(j, SCI_Enable_DAA))
5006 return 0;
5007
5008 bytes.high = inb_p(j->XILINXbase + 0x03);
5009 bytes.low = inb_p(j->XILINXbase + 0x02);
5010 if (bytes.low != ALISDAA_ID_BYTE) {
5011 if (ixjdebug & 0x0001)
5012 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5013 return 0;
5014 }
5015 if (!SCI_Control(j, SCI_Enable_DAA))
5016 return 0;
5017 if (!SCI_Control(j, SCI_End))
5018 return 0;
5019
5020 wdata.word = inw_p(j->XILINXbase + 0x02);
5021
5022 switch(cr){
5023 case 5:
5024 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
5025 break;
5026 case 4:
5027 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
5028 break;
5029 case 3:
5030 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
5031 break;
5032 case 2:
5033 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
5034 break;
5035 case 1:
5036 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
5037 break;
5038 case 0:
5039 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
5040 break;
5041 default:
5042 return 0;
5043 }
5044 return 1;
5045 }
5046
5047 static int ixj_daa_cid_reset(IXJ *j)
5048 {
5049 int i;
5050 BYTES bytes;
5051
5052 if (ixjdebug & 0x0002)
5053 printk("DAA Clearing CID ram\n");
5054
5055 if (!SCI_Prepare(j))
5056 return 0;
5057
5058 bytes.high = 0x58;
5059 bytes.low = 0x00;
5060 outb_p(bytes.high, j->XILINXbase + 0x03);
5061 outb_p(bytes.low, j->XILINXbase + 0x02);
5062
5063 if (!SCI_Control(j, SCI_Enable_DAA))
5064 return 0;
5065
5066 if (!SCI_WaitHighSCI(j))
5067 return 0;
5068
5069 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
5070 bytes.high = bytes.low = 0x00;
5071 outb_p(bytes.high, j->XILINXbase + 0x03);
5072
5073 if (i < ALISDAA_CALLERID_SIZE - 1)
5074 outb_p(bytes.low, j->XILINXbase + 0x02);
5075
5076 if (!SCI_Control(j, SCI_Enable_DAA))
5077 return 0;
5078
5079 if (!SCI_WaitHighSCI(j))
5080 return 0;
5081
5082 }
5083
5084 if (!SCI_Control(j, SCI_End))
5085 return 0;
5086
5087 if (ixjdebug & 0x0002)
5088 printk("DAA CID ram cleared\n");
5089
5090 return 1;
5091 }
5092
5093 static int ixj_daa_cid_read(IXJ *j)
5094 {
5095 int i;
5096 BYTES bytes;
5097 char CID[ALISDAA_CALLERID_SIZE], mContinue;
5098 char *pIn, *pOut;
5099
5100 if (!SCI_Prepare(j))
5101 return 0;
5102
5103 bytes.high = 0x78;
5104 bytes.low = 0x00;
5105 outb_p(bytes.high, j->XILINXbase + 0x03);
5106 outb_p(bytes.low, j->XILINXbase + 0x02);
5107
5108 if (!SCI_Control(j, SCI_Enable_DAA))
5109 return 0;
5110
5111 if (!SCI_WaitHighSCI(j))
5112 return 0;
5113
5114 bytes.high = inb_p(j->XILINXbase + 0x03);
5115 bytes.low = inb_p(j->XILINXbase + 0x02);
5116 if (bytes.low != ALISDAA_ID_BYTE) {
5117 if (ixjdebug & 0x0001)
5118 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5119 return 0;
5120 }
5121 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5122 bytes.high = bytes.low = 0x00;
5123 outb_p(bytes.high, j->XILINXbase + 0x03);
5124 outb_p(bytes.low, j->XILINXbase + 0x02);
5125
5126 if (!SCI_Control(j, SCI_Enable_DAA))
5127 return 0;
5128
5129 if (!SCI_WaitHighSCI(j))
5130 return 0;
5131
5132 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5133 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5134 }
5135
5136 if (!SCI_Control(j, SCI_End))
5137 return 0;
5138
5139 pIn = CID;
5140 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5141 mContinue = 1;
5142 while (mContinue) {
5143 if ((pIn[1] & 0x03) == 0x01) {
5144 pOut[0] = pIn[0];
5145 }
5146 if ((pIn[2] & 0x0c) == 0x04) {
5147 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5148 }
5149 if ((pIn[3] & 0x30) == 0x10) {
5150 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5151 }
5152 if ((pIn[4] & 0xc0) == 0x40) {
5153 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5154 } else {
5155 mContinue = FALSE;
5156 }
5157 pIn += 5, pOut += 4;
5158 }
5159 memset(&j->cid, 0, sizeof(PHONE_CID));
5160 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5161 pOut += 4;
5162 strncpy(j->cid.month, pOut, 2);
5163 pOut += 2;
5164 strncpy(j->cid.day, pOut, 2);
5165 pOut += 2;
5166 strncpy(j->cid.hour, pOut, 2);
5167 pOut += 2;
5168 strncpy(j->cid.min, pOut, 2);
5169 pOut += 3;
5170 j->cid.numlen = *pOut;
5171 pOut += 1;
5172 strncpy(j->cid.number, pOut, j->cid.numlen);
5173 pOut += j->cid.numlen + 1;
5174 j->cid.namelen = *pOut;
5175 pOut += 1;
5176 strncpy(j->cid.name, pOut, j->cid.namelen);
5177
5178 ixj_daa_cid_reset(j);
5179 return 1;
5180 }
5181
5182 static char daa_get_version(IXJ *j)
5183 {
5184 BYTES bytes;
5185
5186 if (!SCI_Prepare(j))
5187 return 0;
5188
5189 bytes.high = 0x35;
5190 bytes.low = 0x00;
5191 outb_p(bytes.high, j->XILINXbase + 0x03);
5192 outb_p(bytes.low, j->XILINXbase + 0x02);
5193
5194 if (!SCI_Control(j, SCI_Enable_DAA))
5195 return 0;
5196
5197 bytes.high = inb_p(j->XILINXbase + 0x03);
5198 bytes.low = inb_p(j->XILINXbase + 0x02);
5199 if (bytes.low != ALISDAA_ID_BYTE) {
5200 if (ixjdebug & 0x0001)
5201 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5202 return 0;
5203 }
5204 if (!SCI_Control(j, SCI_Enable_DAA))
5205 return 0;
5206
5207 if (!SCI_Control(j, SCI_End))
5208 return 0;
5209
5210 bytes.high = inb_p(j->XILINXbase + 0x03);
5211 bytes.low = inb_p(j->XILINXbase + 0x02);
5212 if (ixjdebug & 0x0002)
5213 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5214 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5215 return bytes.high;
5216 }
5217
5218 static int daa_set_mode(IXJ *j, int mode)
5219 {
5220 /* NOTE:
5221 The DAA *MUST* be in the conversation mode if the
5222 PSTN line is to be seized (PSTN line off-hook).
5223 Taking the PSTN line off-hook while the DAA is in
5224 a mode other than conversation mode will cause a
5225 hardware failure of the ALIS-A part.
5226
5227 NOTE:
5228 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5229 if the PSTN line is on-hook. Failure to have the PSTN line
5230 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5231 ALIS-A part.
5232 */
5233
5234 BYTES bytes;
5235
5236 j->flags.pstn_rmr = 0;
5237
5238 if (!SCI_Prepare(j))
5239 return 0;
5240
5241 switch (mode) {
5242 case SOP_PU_RESET:
5243 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5244
5245 outb_p(j->pld_scrw.byte, j->XILINXbase);
5246 j->pld_slicw.bits.rly2 = 0;
5247 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5248 bytes.high = 0x10;
5249 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5250 daa_load(&bytes, j);
5251 if (!SCI_Prepare(j))
5252 return 0;
5253
5254 j->daa_mode = SOP_PU_SLEEP;
5255 break;
5256 case SOP_PU_SLEEP:
5257 if(j->daa_mode == SOP_PU_SLEEP)
5258 {
5259 break;
5260 }
5261 if (ixjdebug & 0x0008)
5262 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5263 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5264 {
5265 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5266
5267 outb_p(j->pld_scrw.byte, j->XILINXbase);
5268 j->pld_slicw.bits.rly2 = 0;
5269 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5270 bytes.high = 0x10;
5271 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5272 daa_load(&bytes, j);
5273 if (!SCI_Prepare(j))
5274 return 0;
5275 }
5276 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5277
5278 outb_p(j->pld_scrw.byte, j->XILINXbase);
5279 j->pld_slicw.bits.rly2 = 0;
5280 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5281 bytes.high = 0x10;
5282 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5283 daa_load(&bytes, j);
5284 if (!SCI_Prepare(j))
5285 return 0;
5286
5287 j->daa_mode = SOP_PU_SLEEP;
5288 j->flags.pstn_ringing = 0;
5289 j->ex.bits.pstn_ring = 0;
5290 j->pstn_sleeptil = jiffies + (hertz / 4);
5291 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5292 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5293 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5294 break;
5295 case SOP_PU_RINGING:
5296 if (ixjdebug & 0x0008)
5297 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5298 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5299
5300 outb_p(j->pld_scrw.byte, j->XILINXbase);
5301 j->pld_slicw.bits.rly2 = 0;
5302 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5303 bytes.high = 0x50;
5304 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5305 daa_load(&bytes, j);
5306 if (!SCI_Prepare(j))
5307 return 0;
5308 j->daa_mode = SOP_PU_RINGING;
5309 break;
5310 case SOP_PU_CONVERSATION:
5311 if (ixjdebug & 0x0008)
5312 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5313 bytes.high = 0x90;
5314 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5315 daa_load(&bytes, j);
5316 if (!SCI_Prepare(j))
5317 return 0;
5318 j->pld_slicw.bits.rly2 = 1;
5319 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5320 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5321
5322 outb_p(j->pld_scrw.byte, j->XILINXbase);
5323 j->daa_mode = SOP_PU_CONVERSATION;
5324 j->flags.pstn_ringing = 0;
5325 j->ex.bits.pstn_ring = 0;
5326 j->pstn_sleeptil = jiffies;
5327 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5328 break;
5329 case SOP_PU_PULSEDIALING:
5330 if (ixjdebug & 0x0008)
5331 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5332 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5333
5334 outb_p(j->pld_scrw.byte, j->XILINXbase);
5335 j->pld_slicw.bits.rly2 = 0;
5336 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5337 bytes.high = 0xD0;
5338 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5339 daa_load(&bytes, j);
5340 if (!SCI_Prepare(j))
5341 return 0;
5342 j->daa_mode = SOP_PU_PULSEDIALING;
5343 break;
5344 default:
5345 break;
5346 }
5347 return 1;
5348 }
5349
5350 static int ixj_daa_write(IXJ *j)
5351 {
5352 BYTES bytes;
5353
5354 j->flags.pstncheck = 1;
5355
5356 daa_set_mode(j, SOP_PU_SLEEP);
5357
5358 if (!SCI_Prepare(j))
5359 return 0;
5360
5361 outb_p(j->pld_scrw.byte, j->XILINXbase);
5362
5363 bytes.high = 0x14;
5364 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5365 if (!daa_load(&bytes, j))
5366 return 0;
5367
5368 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5369 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5370 if (!daa_load(&bytes, j))
5371 return 0;
5372
5373 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5374 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5375 if (!daa_load(&bytes, j))
5376 return 0;
5377
5378 if (!SCI_Prepare(j))
5379 return 0;
5380
5381 bytes.high = 0x1F;
5382 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5383 if (!daa_load(&bytes, j))
5384 return 0;
5385
5386 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5387 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5388 if (!daa_load(&bytes, j))
5389 return 0;
5390
5391 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5392 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5393 if (!daa_load(&bytes, j))
5394 return 0;
5395
5396 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5397 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5398 if (!daa_load(&bytes, j))
5399 return 0;
5400
5401 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5402 bytes.low = 0x00;
5403 if (!daa_load(&bytes, j))
5404 return 0;
5405
5406 if (!SCI_Prepare(j))
5407 return 0;
5408
5409 bytes.high = 0x00;
5410 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5411 if (!daa_load(&bytes, j))
5412 return 0;
5413
5414 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5415 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5416 if (!daa_load(&bytes, j))
5417 return 0;
5418
5419 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5420 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5421 if (!daa_load(&bytes, j))
5422 return 0;
5423
5424 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5425 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5426 if (!daa_load(&bytes, j))
5427 return 0;
5428
5429 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5430 bytes.low = 0x00;
5431 if (!daa_load(&bytes, j))
5432 return 0;
5433
5434 if (!SCI_Control(j, SCI_End))
5435 return 0;
5436 if (!SCI_WaitLowSCI(j))
5437 return 0;
5438
5439 bytes.high = 0x01;
5440 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5441 if (!daa_load(&bytes, j))
5442 return 0;
5443
5444 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5445 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5446 if (!daa_load(&bytes, j))
5447 return 0;
5448
5449 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5450 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5451 if (!daa_load(&bytes, j))
5452 return 0;
5453
5454 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5455 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5456 if (!daa_load(&bytes, j))
5457 return 0;
5458
5459 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5460 bytes.low = 0x00;
5461 if (!daa_load(&bytes, j))
5462 return 0;
5463
5464 if (!SCI_Control(j, SCI_End))
5465 return 0;
5466 if (!SCI_WaitLowSCI(j))
5467 return 0;
5468
5469 bytes.high = 0x02;
5470 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5471 if (!daa_load(&bytes, j))
5472 return 0;
5473
5474 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5475 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5476 if (!daa_load(&bytes, j))
5477 return 0;
5478
5479 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5480 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5481 if (!daa_load(&bytes, j))
5482 return 0;
5483
5484 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5485 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5486 if (!daa_load(&bytes, j))
5487 return 0;
5488
5489 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5490 bytes.low = 0x00;
5491 if (!daa_load(&bytes, j))
5492 return 0;
5493
5494 if (!SCI_Control(j, SCI_End))
5495 return 0;
5496 if (!SCI_WaitLowSCI(j))
5497 return 0;
5498
5499 bytes.high = 0x03;
5500 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5501 if (!daa_load(&bytes, j))
5502 return 0;
5503
5504 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5505 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5506 if (!daa_load(&bytes, j))
5507 return 0;
5508
5509 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5510 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5511 if (!daa_load(&bytes, j))
5512 return 0;
5513
5514 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5515 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5516 if (!daa_load(&bytes, j))
5517 return 0;
5518
5519 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5520 bytes.low = 0x00;
5521 if (!daa_load(&bytes, j))
5522 return 0;
5523
5524 if (!SCI_Control(j, SCI_End))
5525 return 0;
5526 if (!SCI_WaitLowSCI(j))
5527 return 0;
5528
5529 bytes.high = 0x04;
5530 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5531 if (!daa_load(&bytes, j))
5532 return 0;
5533
5534 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5535 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5536 if (!daa_load(&bytes, j))
5537 return 0;
5538
5539 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5540 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5541 if (!daa_load(&bytes, j))
5542 return 0;
5543
5544 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5545 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5546 if (!daa_load(&bytes, j))
5547 return 0;
5548
5549 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5550 bytes.low = 0x00;
5551 if (!daa_load(&bytes, j))
5552 return 0;
5553
5554 if (!SCI_Control(j, SCI_End))
5555 return 0;
5556 if (!SCI_WaitLowSCI(j))
5557 return 0;
5558
5559 bytes.high = 0x05;
5560 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5561 if (!daa_load(&bytes, j))
5562 return 0;
5563
5564 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5565 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5566 if (!daa_load(&bytes, j))
5567 return 0;
5568
5569 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5570 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5571 if (!daa_load(&bytes, j))
5572 return 0;
5573
5574 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5575 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5576 if (!daa_load(&bytes, j))
5577 return 0;
5578
5579 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5580 bytes.low = 0x00;
5581 if (!daa_load(&bytes, j))
5582 return 0;
5583
5584 if (!SCI_Control(j, SCI_End))
5585 return 0;
5586 if (!SCI_WaitLowSCI(j))
5587 return 0;
5588
5589 bytes.high = 0x06;
5590 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5591 if (!daa_load(&bytes, j))
5592 return 0;
5593
5594 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5595 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5596 if (!daa_load(&bytes, j))
5597 return 0;
5598
5599 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5600 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5601 if (!daa_load(&bytes, j))
5602 return 0;
5603
5604 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5605 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5606 if (!daa_load(&bytes, j))
5607 return 0;
5608
5609 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5610 bytes.low = 0x00;
5611 if (!daa_load(&bytes, j))
5612 return 0;
5613
5614 if (!SCI_Control(j, SCI_End))
5615 return 0;
5616 if (!SCI_WaitLowSCI(j))
5617 return 0;
5618
5619 bytes.high = 0x07;
5620 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5621 if (!daa_load(&bytes, j))
5622 return 0;
5623
5624 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5625 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5626 if (!daa_load(&bytes, j))
5627 return 0;
5628
5629 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5630 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5631 if (!daa_load(&bytes, j))
5632 return 0;
5633
5634 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5635 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5636 if (!daa_load(&bytes, j))
5637 return 0;
5638
5639 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5640 bytes.low = 0x00;
5641 if (!daa_load(&bytes, j))
5642 return 0;
5643
5644 if (!SCI_Control(j, SCI_End))
5645 return 0;
5646 if (!SCI_WaitLowSCI(j))
5647 return 0;
5648
5649 bytes.high = 0x08;
5650 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5651 if (!daa_load(&bytes, j))
5652 return 0;
5653
5654 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5655 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5656 if (!daa_load(&bytes, j))
5657 return 0;
5658
5659 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5660 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5661 if (!daa_load(&bytes, j))
5662 return 0;
5663
5664 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5665 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5666 if (!daa_load(&bytes, j))
5667 return 0;
5668
5669 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5670 bytes.low = 0x00;
5671 if (!daa_load(&bytes, j))
5672 return 0;
5673
5674 if (!SCI_Control(j, SCI_End))
5675 return 0;
5676 if (!SCI_WaitLowSCI(j))
5677 return 0;
5678
5679 bytes.high = 0x09;
5680 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5681 if (!daa_load(&bytes, j))
5682 return 0;
5683
5684 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5685 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5686 if (!daa_load(&bytes, j))
5687 return 0;
5688
5689 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5690 bytes.low = 0x00;
5691 if (!daa_load(&bytes, j))
5692 return 0;
5693
5694 if (!SCI_Control(j, SCI_End))
5695 return 0;
5696 if (!SCI_WaitLowSCI(j))
5697 return 0;
5698
5699 bytes.high = 0x0A;
5700 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5701 if (!daa_load(&bytes, j))
5702 return 0;
5703
5704 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5705 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5706 if (!daa_load(&bytes, j))
5707 return 0;
5708
5709 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5710 bytes.low = 0x00;
5711 if (!daa_load(&bytes, j))
5712 return 0;
5713
5714 if (!SCI_Control(j, SCI_End))
5715 return 0;
5716 if (!SCI_WaitLowSCI(j))
5717 return 0;
5718
5719 bytes.high = 0x0B;
5720 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5721 if (!daa_load(&bytes, j))
5722 return 0;
5723
5724 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5725 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5726 if (!daa_load(&bytes, j))
5727 return 0;
5728
5729 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5730 bytes.low = 0x00;
5731 if (!daa_load(&bytes, j))
5732 return 0;
5733
5734 if (!SCI_Control(j, SCI_End))
5735 return 0;
5736 if (!SCI_WaitLowSCI(j))
5737 return 0;
5738
5739 bytes.high = 0x0C;
5740 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5741 if (!daa_load(&bytes, j))
5742 return 0;
5743
5744 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5745 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5746 if (!daa_load(&bytes, j))
5747 return 0;
5748
5749 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5750 bytes.low = 0x00;
5751 if (!daa_load(&bytes, j))
5752 return 0;
5753
5754 if (!SCI_Control(j, SCI_End))
5755 return 0;
5756 if (!SCI_WaitLowSCI(j))
5757 return 0;
5758
5759 bytes.high = 0x0D;
5760 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5761 if (!daa_load(&bytes, j))
5762 return 0;
5763
5764 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5765 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5766 if (!daa_load(&bytes, j))
5767 return 0;
5768
5769 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5770 bytes.low = 0x00;
5771 if (!daa_load(&bytes, j))
5772 return 0;
5773
5774 if (!SCI_Control(j, SCI_End))
5775 return 0;
5776 if (!SCI_WaitLowSCI(j))
5777 return 0;
5778
5779 bytes.high = 0x0E;
5780 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5781 if (!daa_load(&bytes, j))
5782 return 0;
5783
5784 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5785 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5786 if (!daa_load(&bytes, j))
5787 return 0;
5788
5789 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5790 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5791 if (!daa_load(&bytes, j))
5792 return 0;
5793
5794 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5795 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5796 if (!daa_load(&bytes, j))
5797 return 0;
5798
5799 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5800 bytes.low = 0x00;
5801 if (!daa_load(&bytes, j))
5802 return 0;
5803
5804 if (!SCI_Control(j, SCI_End))
5805 return 0;
5806 if (!SCI_WaitLowSCI(j))
5807 return 0;
5808
5809 bytes.high = 0x0F;
5810 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5811 if (!daa_load(&bytes, j))
5812 return 0;
5813
5814 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5815 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5816 if (!daa_load(&bytes, j))
5817 return 0;
5818
5819 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5820 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5821 if (!daa_load(&bytes, j))
5822 return 0;
5823
5824 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5825 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5826 if (!daa_load(&bytes, j))
5827 return 0;
5828
5829 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5830 bytes.low = 0x00;
5831 if (!daa_load(&bytes, j))
5832 return 0;
5833
5834 udelay(32);
5835 j->pld_scrr.byte = inb_p(j->XILINXbase);
5836 if (!SCI_Control(j, SCI_End))
5837 return 0;
5838
5839 outb_p(j->pld_scrw.byte, j->XILINXbase);
5840
5841 if (ixjdebug & 0x0002)
5842 printk("DAA Coefficients Loaded\n");
5843
5844 j->flags.pstncheck = 0;
5845 return 1;
5846 }
5847
5848 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5849 {
5850 j->tone_off_time = arg;
5851 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5852
5853 return -1;
5854 if (ixj_WriteDSPCommand(arg, j))
5855 return -1;
5856 return 0;
5857 }
5858
5859 static int ixj_get_tone_on(IXJ *j)
5860 {
5861 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5862
5863 return -1;
5864 return 0;
5865 }
5866
5867 static int ixj_get_tone_off(IXJ *j)
5868 {
5869 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5870
5871 return -1;
5872 return 0;
5873 }
5874
5875 static void ixj_busytone(IXJ *j)
5876 {
5877 j->flags.ringback = 0;
5878 j->flags.dialtone = 0;
5879 j->flags.busytone = 1;
5880 ixj_set_tone_on(0x07D0, j);
5881 ixj_set_tone_off(0x07D0, j);
5882 ixj_play_tone(j, 27);
5883 }
5884
5885 static void ixj_dialtone(IXJ *j)
5886 {
5887 j->flags.ringback = 0;
5888 j->flags.dialtone = 1;
5889 j->flags.busytone = 0;
5890 if (j->dsp.low == 0x20) {
5891 return;
5892 } else {
5893 ixj_set_tone_on(0xFFFF, j);
5894 ixj_set_tone_off(0x0000, j);
5895 ixj_play_tone(j, 25);
5896 }
5897 }
5898
5899 static void ixj_cpt_stop(IXJ *j)
5900 {
5901 if(j->tone_state || j->tone_cadence_state)
5902 {
5903 j->flags.dialtone = 0;
5904 j->flags.busytone = 0;
5905 j->flags.ringback = 0;
5906 ixj_set_tone_on(0x0001, j);
5907 ixj_set_tone_off(0x0000, j);
5908 ixj_play_tone(j, 0);
5909 j->tone_state = j->tone_cadence_state = 0;
5910 if (j->cadence_t) {
5911 if (j->cadence_t->ce) {
5912 kfree(j->cadence_t->ce);
5913 }
5914 kfree(j->cadence_t);
5915 j->cadence_t = NULL;
5916 }
5917 }
5918 if (j->play_mode == -1 && j->rec_mode == -1)
5919 idle(j);
5920 if (j->play_mode != -1 && j->dsp.low == 0x20)
5921 ixj_play_start(j);
5922 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5923 ixj_record_start(j);
5924 }
5925
5926 static void ixj_ringback(IXJ *j)
5927 {
5928 j->flags.busytone = 0;
5929 j->flags.dialtone = 0;
5930 j->flags.ringback = 1;
5931 ixj_set_tone_on(0x0FA0, j);
5932 ixj_set_tone_off(0x2EE0, j);
5933 ixj_play_tone(j, 26);
5934 }
5935
5936 static void ixj_testram(IXJ *j)
5937 {
5938 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5939 }
5940
5941 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5942 {
5943 ixj_cadence *lcp;
5944 IXJ_CADENCE_ELEMENT __user *cep;
5945 IXJ_CADENCE_ELEMENT *lcep;
5946 IXJ_TONE ti;
5947 int err;
5948
5949 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5950 if (lcp == NULL)
5951 return -ENOMEM;
5952
5953 err = -EFAULT;
5954 if (copy_from_user(&lcp->elements_used,
5955 &cp->elements_used, sizeof(int)))
5956 goto out;
5957 if (copy_from_user(&lcp->termination,
5958 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5959 goto out;
5960 if (get_user(cep, &cp->ce))
5961 goto out;
5962
5963 err = -EINVAL;
5964 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5965 goto out;
5966
5967 err = -ENOMEM;
5968 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5969 if (!lcep)
5970 goto out;
5971
5972 err = -EFAULT;
5973 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5974 goto out1;
5975
5976 if (j->cadence_t) {
5977 kfree(j->cadence_t->ce);
5978 kfree(j->cadence_t);
5979 }
5980 lcp->ce = (void *) lcep;
5981 j->cadence_t = lcp;
5982 j->tone_cadence_state = 0;
5983 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5984 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5985 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5986 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5987 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5988 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5989 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5990 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5991 ixj_init_tone(j, &ti);
5992 }
5993 ixj_play_tone(j, lcp->ce[0].index);
5994 return 1;
5995 out1:
5996 kfree(lcep);
5997 out:
5998 kfree(lcp);
5999 return err;
6000 }
6001
6002 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
6003 {
6004 IXJ_FILTER_CADENCE *lcp;
6005 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
6006 if (lcp == NULL) {
6007 if(ixjdebug & 0x0001) {
6008 printk(KERN_INFO "Could not allocate memory for cadence\n");
6009 }
6010 return -ENOMEM;
6011 }
6012 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
6013 if(ixjdebug & 0x0001) {
6014 printk(KERN_INFO "Could not copy cadence to kernel\n");
6015 }
6016 kfree(lcp);
6017 return -EFAULT;
6018 }
6019 if (lcp->filter > 5) {
6020 if(ixjdebug & 0x0001) {
6021 printk(KERN_INFO "Cadence out of range\n");
6022 }
6023 kfree(lcp);
6024 return -1;
6025 }
6026 j->cadence_f[lcp->filter].state = 0;
6027 j->cadence_f[lcp->filter].enable = lcp->enable;
6028 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
6029 j->cadence_f[lcp->filter].on1 = lcp->on1;
6030 j->cadence_f[lcp->filter].on1min = 0;
6031 j->cadence_f[lcp->filter].on1max = 0;
6032 j->cadence_f[lcp->filter].off1 = lcp->off1;
6033 j->cadence_f[lcp->filter].off1min = 0;
6034 j->cadence_f[lcp->filter].off1max = 0;
6035 j->cadence_f[lcp->filter].on2 = lcp->on2;
6036 j->cadence_f[lcp->filter].on2min = 0;
6037 j->cadence_f[lcp->filter].on2max = 0;
6038 j->cadence_f[lcp->filter].off2 = lcp->off2;
6039 j->cadence_f[lcp->filter].off2min = 0;
6040 j->cadence_f[lcp->filter].off2max = 0;
6041 j->cadence_f[lcp->filter].on3 = lcp->on3;
6042 j->cadence_f[lcp->filter].on3min = 0;
6043 j->cadence_f[lcp->filter].on3max = 0;
6044 j->cadence_f[lcp->filter].off3 = lcp->off3;
6045 j->cadence_f[lcp->filter].off3min = 0;
6046 j->cadence_f[lcp->filter].off3max = 0;
6047 kfree(lcp);
6048 if(ixjdebug & 0x0002) {
6049 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
6050 }
6051 return 0;
6052 }
6053
6054 static void add_caps(IXJ *j)
6055 {
6056 j->caps = 0;
6057 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
6058 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
6059 j->caplist[j->caps].captype = vendor;
6060 j->caplist[j->caps].handle = j->caps++;
6061 j->caplist[j->caps].captype = device;
6062 switch (j->cardtype) {
6063 case QTI_PHONEJACK:
6064 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
6065 break;
6066 case QTI_LINEJACK:
6067 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
6068 break;
6069 case QTI_PHONEJACK_LITE:
6070 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
6071 break;
6072 case QTI_PHONEJACK_PCI:
6073 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
6074 break;
6075 case QTI_PHONECARD:
6076 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
6077 break;
6078 }
6079 j->caplist[j->caps].cap = j->cardtype;
6080 j->caplist[j->caps].handle = j->caps++;
6081 strcpy(j->caplist[j->caps].desc, "POTS");
6082 j->caplist[j->caps].captype = port;
6083 j->caplist[j->caps].cap = pots;
6084 j->caplist[j->caps].handle = j->caps++;
6085
6086 /* add devices that can do speaker/mic */
6087 switch (j->cardtype) {
6088 case QTI_PHONEJACK:
6089 case QTI_LINEJACK:
6090 case QTI_PHONEJACK_PCI:
6091 case QTI_PHONECARD:
6092 strcpy(j->caplist[j->caps].desc, "SPEAKER");
6093 j->caplist[j->caps].captype = port;
6094 j->caplist[j->caps].cap = speaker;
6095 j->caplist[j->caps].handle = j->caps++;
6096 default:
6097 break;
6098 }
6099
6100 /* add devices that can do handset */
6101 switch (j->cardtype) {
6102 case QTI_PHONEJACK:
6103 strcpy(j->caplist[j->caps].desc, "HANDSET");
6104 j->caplist[j->caps].captype = port;
6105 j->caplist[j->caps].cap = handset;
6106 j->caplist[j->caps].handle = j->caps++;
6107 break;
6108 default:
6109 break;
6110 }
6111
6112 /* add devices that can do PSTN */
6113 switch (j->cardtype) {
6114 case QTI_LINEJACK:
6115 strcpy(j->caplist[j->caps].desc, "PSTN");
6116 j->caplist[j->caps].captype = port;
6117 j->caplist[j->caps].cap = pstn;
6118 j->caplist[j->caps].handle = j->caps++;
6119 break;
6120 default:
6121 break;
6122 }
6123
6124 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6125 strcpy(j->caplist[j->caps].desc, "ULAW");
6126 j->caplist[j->caps].captype = codec;
6127 j->caplist[j->caps].cap = ULAW;
6128 j->caplist[j->caps].handle = j->caps++;
6129
6130 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6131 j->caplist[j->caps].captype = codec;
6132 j->caplist[j->caps].cap = LINEAR16;
6133 j->caplist[j->caps].handle = j->caps++;
6134
6135 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6136 j->caplist[j->caps].captype = codec;
6137 j->caplist[j->caps].cap = LINEAR8;
6138 j->caplist[j->caps].handle = j->caps++;
6139
6140 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6141 j->caplist[j->caps].captype = codec;
6142 j->caplist[j->caps].cap = WSS;
6143 j->caplist[j->caps].handle = j->caps++;
6144
6145 /* software ALAW codec, made from ULAW */
6146 strcpy(j->caplist[j->caps].desc, "ALAW");
6147 j->caplist[j->caps].captype = codec;
6148 j->caplist[j->caps].cap = ALAW;
6149 j->caplist[j->caps].handle = j->caps++;
6150
6151 /* version 12 of the 8020 does the following codecs in a broken way */
6152 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6153 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6154 j->caplist[j->caps].captype = codec;
6155 j->caplist[j->caps].cap = G723_63;
6156 j->caplist[j->caps].handle = j->caps++;
6157
6158 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6159 j->caplist[j->caps].captype = codec;
6160 j->caplist[j->caps].cap = G723_53;
6161 j->caplist[j->caps].handle = j->caps++;
6162
6163 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6164 j->caplist[j->caps].captype = codec;
6165 j->caplist[j->caps].cap = TS48;
6166 j->caplist[j->caps].handle = j->caps++;
6167
6168 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6169 j->caplist[j->caps].captype = codec;
6170 j->caplist[j->caps].cap = TS41;
6171 j->caplist[j->caps].handle = j->caps++;
6172 }
6173
6174 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6175 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6176 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6177 j->caplist[j->caps].captype = codec;
6178 j->caplist[j->caps].cap = TS85;
6179 j->caplist[j->caps].handle = j->caps++;
6180 }
6181
6182 /* 8021 chips can do G728 */
6183 if (j->dsp.low == 0x21) {
6184 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6185 j->caplist[j->caps].captype = codec;
6186 j->caplist[j->caps].cap = G728;
6187 j->caplist[j->caps].handle = j->caps++;
6188 }
6189
6190 /* 8021/8022 chips can do G729 if loaded */
6191 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6192 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6193 j->caplist[j->caps].captype = codec;
6194 j->caplist[j->caps].cap = G729;
6195 j->caplist[j->caps].handle = j->caps++;
6196 }
6197 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6198 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6199 j->caplist[j->caps].captype = codec;
6200 j->caplist[j->caps].cap = G729B;
6201 j->caplist[j->caps].handle = j->caps++;
6202 }
6203 }
6204
6205 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6206 {
6207 int cnt;
6208 int retval = 0;
6209 for (cnt = 0; cnt < j->caps; cnt++) {
6210 if (pcreq->captype == j->caplist[cnt].captype
6211 && pcreq->cap == j->caplist[cnt].cap) {
6212 retval = 1;
6213 break;
6214 }
6215 }
6216 return retval;
6217 }
6218
6219 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6220 {
6221 IXJ_TONE ti;
6222 IXJ_FILTER jf;
6223 IXJ_FILTER_RAW jfr;
6224 void __user *argp = (void __user *)arg;
6225
6226 unsigned int raise, mant;
6227 unsigned int minor = iminor(inode);
6228 int board = NUM(inode);
6229
6230 IXJ *j = get_ixj(NUM(inode));
6231
6232 int retval = 0;
6233
6234 /*
6235 * Set up locks to ensure that only one process is talking to the DSP at a time.
6236 * This is necessary to keep the DSP from locking up.
6237 */
6238 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6239 set_current_state(TASK_INTERRUPTIBLE);
6240 schedule_timeout(1);
6241 }
6242 if (ixjdebug & 0x0040)
6243 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6244 if (minor >= IXJMAX) {
6245 clear_bit(board, &j->busyflags);
6246 return -ENODEV;
6247 }
6248 /*
6249 * Check ioctls only root can use.
6250 */
6251 if (!capable(CAP_SYS_ADMIN)) {
6252 switch (cmd) {
6253 case IXJCTL_TESTRAM:
6254 case IXJCTL_HZ:
6255 retval = -EPERM;
6256 }
6257 }
6258 switch (cmd) {
6259 case IXJCTL_TESTRAM:
6260 ixj_testram(j);
6261 retval = (j->ssr.high << 8) + j->ssr.low;
6262 break;
6263 case IXJCTL_CARDTYPE:
6264 retval = j->cardtype;
6265 break;
6266 case IXJCTL_SERIAL:
6267 retval = j->serial;
6268 break;
6269 case IXJCTL_VERSION:
6270 if (copy_to_user(argp, ixj_c_revision, strlen(ixj_c_revision)))
6271 retval = -EFAULT;
6272 break;
6273 case PHONE_RING_CADENCE:
6274 j->ring_cadence = arg;
6275 break;
6276 case IXJCTL_CIDCW:
6277 if(arg) {
6278 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6279 retval = -EFAULT;
6280 break;
6281 }
6282 } else {
6283 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6284 }
6285 ixj_write_cidcw(j);
6286 break;
6287 /* Binary compatbility */
6288 case OLD_PHONE_RING_START:
6289 arg = 0;
6290 /* Fall through */
6291 case PHONE_RING_START:
6292 if(arg) {
6293 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6294 retval = -EFAULT;
6295 break;
6296 }
6297 ixj_write_cid(j);
6298 } else {
6299 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6300 }
6301 ixj_ring_start(j);
6302 break;
6303 case PHONE_RING_STOP:
6304 j->flags.cringing = 0;
6305 if(j->cadence_f[5].enable) {
6306 j->cadence_f[5].state = 0;
6307 }
6308 ixj_ring_off(j);
6309 break;
6310 case PHONE_RING:
6311 retval = ixj_ring(j);
6312 break;
6313 case PHONE_EXCEPTION:
6314 retval = j->ex.bytes;
6315 if(j->ex.bits.flash) {
6316 j->flash_end = 0;
6317 j->ex.bits.flash = 0;
6318 }
6319 j->ex.bits.pstn_ring = 0;
6320 j->ex.bits.caller_id = 0;
6321 j->ex.bits.pstn_wink = 0;
6322 j->ex.bits.f0 = 0;
6323 j->ex.bits.f1 = 0;
6324 j->ex.bits.f2 = 0;
6325 j->ex.bits.f3 = 0;
6326 j->ex.bits.fc0 = 0;
6327 j->ex.bits.fc1 = 0;
6328 j->ex.bits.fc2 = 0;
6329 j->ex.bits.fc3 = 0;
6330 j->ex.bits.reserved = 0;
6331 break;
6332 case PHONE_HOOKSTATE:
6333 j->ex.bits.hookstate = 0;
6334 retval = j->hookstate; //j->r_hook;
6335 break;
6336 case IXJCTL_SET_LED:
6337 LED_SetState(arg, j);
6338 break;
6339 case PHONE_FRAME:
6340 retval = set_base_frame(j, arg);
6341 break;
6342 case PHONE_REC_CODEC:
6343 retval = set_rec_codec(j, arg);
6344 break;
6345 case PHONE_VAD:
6346 ixj_vad(j, arg);
6347 break;
6348 case PHONE_REC_START:
6349 ixj_record_start(j);
6350 break;
6351 case PHONE_REC_STOP:
6352 ixj_record_stop(j);
6353 break;
6354 case PHONE_REC_DEPTH:
6355 set_rec_depth(j, arg);
6356 break;
6357 case PHONE_REC_VOLUME:
6358 if(arg == -1) {
6359 retval = get_rec_volume(j);
6360 }
6361 else {
6362 set_rec_volume(j, arg);
6363 retval = arg;
6364 }
6365 break;
6366 case PHONE_REC_VOLUME_LINEAR:
6367 if(arg == -1) {
6368 retval = get_rec_volume_linear(j);
6369 }
6370 else {
6371 set_rec_volume_linear(j, arg);
6372 retval = arg;
6373 }
6374 break;
6375 case IXJCTL_DTMF_PRESCALE:
6376 if(arg == -1) {
6377 retval = get_dtmf_prescale(j);
6378 }
6379 else {
6380 set_dtmf_prescale(j, arg);
6381 retval = arg;
6382 }
6383 break;
6384 case PHONE_REC_LEVEL:
6385 retval = get_rec_level(j);
6386 break;
6387 case IXJCTL_SC_RXG:
6388 retval = ixj_siadc(j, arg);
6389 break;
6390 case IXJCTL_SC_TXG:
6391 retval = ixj_sidac(j, arg);
6392 break;
6393 case IXJCTL_AEC_START:
6394 ixj_aec_start(j, arg);
6395 break;
6396 case IXJCTL_AEC_STOP:
6397 aec_stop(j);
6398 break;
6399 case IXJCTL_AEC_GET_LEVEL:
6400 retval = j->aec_level;
6401 break;
6402 case PHONE_PLAY_CODEC:
6403 retval = set_play_codec(j, arg);
6404 break;
6405 case PHONE_PLAY_START:
6406 retval = ixj_play_start(j);
6407 break;
6408 case PHONE_PLAY_STOP:
6409 ixj_play_stop(j);
6410 break;
6411 case PHONE_PLAY_DEPTH:
6412 set_play_depth(j, arg);
6413 break;
6414 case PHONE_PLAY_VOLUME:
6415 if(arg == -1) {
6416 retval = get_play_volume(j);
6417 }
6418 else {
6419 set_play_volume(j, arg);
6420 retval = arg;
6421 }
6422 break;
6423 case PHONE_PLAY_VOLUME_LINEAR:
6424 if(arg == -1) {
6425 retval = get_play_volume_linear(j);
6426 }
6427 else {
6428 set_play_volume_linear(j, arg);
6429 retval = arg;
6430 }
6431 break;
6432 case PHONE_PLAY_LEVEL:
6433 retval = get_play_level(j);
6434 break;
6435 case IXJCTL_DSP_TYPE:
6436 retval = (j->dsp.high << 8) + j->dsp.low;
6437 break;
6438 case IXJCTL_DSP_VERSION:
6439 retval = (j->ver.high << 8) + j->ver.low;
6440 break;
6441 case IXJCTL_HZ:
6442 hertz = arg;
6443 break;
6444 case IXJCTL_RATE:
6445 if (arg > hertz)
6446 retval = -1;
6447 else
6448 samplerate = arg;
6449 break;
6450 case IXJCTL_DRYBUFFER_READ:
6451 put_user(j->drybuffer, (unsigned long __user *) argp);
6452 break;
6453 case IXJCTL_DRYBUFFER_CLEAR:
6454 j->drybuffer = 0;
6455 break;
6456 case IXJCTL_FRAMES_READ:
6457 put_user(j->framesread, (unsigned long __user *) argp);
6458 break;
6459 case IXJCTL_FRAMES_WRITTEN:
6460 put_user(j->frameswritten, (unsigned long __user *) argp);
6461 break;
6462 case IXJCTL_READ_WAIT:
6463 put_user(j->read_wait, (unsigned long __user *) argp);
6464 break;
6465 case IXJCTL_WRITE_WAIT:
6466 put_user(j->write_wait, (unsigned long __user *) argp);
6467 break;
6468 case PHONE_MAXRINGS:
6469 j->maxrings = arg;
6470 break;
6471 case PHONE_SET_TONE_ON_TIME:
6472 ixj_set_tone_on(arg, j);
6473 break;
6474 case PHONE_SET_TONE_OFF_TIME:
6475 ixj_set_tone_off(arg, j);
6476 break;
6477 case PHONE_GET_TONE_ON_TIME:
6478 if (ixj_get_tone_on(j)) {
6479 retval = -1;
6480 } else {
6481 retval = (j->ssr.high << 8) + j->ssr.low;
6482 }
6483 break;
6484 case PHONE_GET_TONE_OFF_TIME:
6485 if (ixj_get_tone_off(j)) {
6486 retval = -1;
6487 } else {
6488 retval = (j->ssr.high << 8) + j->ssr.low;
6489 }
6490 break;
6491 case PHONE_PLAY_TONE:
6492 if (!j->tone_state)
6493 retval = ixj_play_tone(j, arg);
6494 else
6495 retval = -1;
6496 break;
6497 case PHONE_GET_TONE_STATE:
6498 retval = j->tone_state;
6499 break;
6500 case PHONE_DTMF_READY:
6501 retval = j->ex.bits.dtmf_ready;
6502 break;
6503 case PHONE_GET_DTMF:
6504 if (ixj_hookstate(j)) {
6505 if (j->dtmf_rp != j->dtmf_wp) {
6506 retval = j->dtmfbuffer[j->dtmf_rp];
6507 j->dtmf_rp++;
6508 if (j->dtmf_rp == 79)
6509 j->dtmf_rp = 0;
6510 if (j->dtmf_rp == j->dtmf_wp) {
6511 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6512 }
6513 }
6514 }
6515 break;
6516 case PHONE_GET_DTMF_ASCII:
6517 if (ixj_hookstate(j)) {
6518 if (j->dtmf_rp != j->dtmf_wp) {
6519 switch (j->dtmfbuffer[j->dtmf_rp]) {
6520 case 10:
6521 retval = 42; /* '*'; */
6522
6523 break;
6524 case 11:
6525 retval = 48; /*'0'; */
6526
6527 break;
6528 case 12:
6529 retval = 35; /*'#'; */
6530
6531 break;
6532 case 28:
6533 retval = 65; /*'A'; */
6534
6535 break;
6536 case 29:
6537 retval = 66; /*'B'; */
6538
6539 break;
6540 case 30:
6541 retval = 67; /*'C'; */
6542
6543 break;
6544 case 31:
6545 retval = 68; /*'D'; */
6546
6547 break;
6548 default:
6549 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6550 break;
6551 }
6552 j->dtmf_rp++;
6553 if (j->dtmf_rp == 79)
6554 j->dtmf_rp = 0;
6555 if(j->dtmf_rp == j->dtmf_wp)
6556 {
6557 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6558 }
6559 }
6560 }
6561 break;
6562 case PHONE_DTMF_OOB:
6563 j->flags.dtmf_oob = arg;
6564 break;
6565 case PHONE_DIALTONE:
6566 ixj_dialtone(j);
6567 break;
6568 case PHONE_BUSY:
6569 ixj_busytone(j);
6570 break;
6571 case PHONE_RINGBACK:
6572 ixj_ringback(j);
6573 break;
6574 case PHONE_WINK:
6575 if(j->cardtype == QTI_PHONEJACK)
6576 retval = -1;
6577 else
6578 retval = ixj_wink(j);
6579 break;
6580 case PHONE_CPT_STOP:
6581 ixj_cpt_stop(j);
6582 break;
6583 case PHONE_QUERY_CODEC:
6584 {
6585 struct phone_codec_data pd;
6586 int val;
6587 int proto_size[] = {
6588 -1,
6589 12, 10, 16, 9, 8, 48, 5,
6590 40, 40, 80, 40, 40, 6
6591 };
6592 if(copy_from_user(&pd, argp, sizeof(pd))) {
6593 retval = -EFAULT;
6594 break;
6595 }
6596 if(pd.type<1 || pd.type>13) {
6597 retval = -EPROTONOSUPPORT;
6598 break;
6599 }
6600 if(pd.type<G729)
6601 val=proto_size[pd.type];
6602 else switch(j->baseframe.low)
6603 {
6604 case 0xA0:val=2*proto_size[pd.type];break;
6605 case 0x50:val=proto_size[pd.type];break;
6606 default:val=proto_size[pd.type]*3;break;
6607 }
6608 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6609 if(copy_to_user(argp, &pd, sizeof(pd)))
6610 retval = -EFAULT;
6611 break;
6612 }
6613 case IXJCTL_DSP_IDLE:
6614 idle(j);
6615 break;
6616 case IXJCTL_MIXER:
6617 if ((arg & 0xff) == 0xff)
6618 retval = ixj_get_mixer(arg, j);
6619 else
6620 ixj_mixer(arg, j);
6621 break;
6622 case IXJCTL_DAA_COEFF_SET:
6623 switch (arg) {
6624 case DAA_US:
6625 DAA_Coeff_US(j);
6626 retval = ixj_daa_write(j);
6627 break;
6628 case DAA_UK:
6629 DAA_Coeff_UK(j);
6630 retval = ixj_daa_write(j);
6631 break;
6632 case DAA_FRANCE:
6633 DAA_Coeff_France(j);
6634 retval = ixj_daa_write(j);
6635 break;
6636 case DAA_GERMANY:
6637 DAA_Coeff_Germany(j);
6638 retval = ixj_daa_write(j);
6639 break;
6640 case DAA_AUSTRALIA:
6641 DAA_Coeff_Australia(j);
6642 retval = ixj_daa_write(j);
6643 break;
6644 case DAA_JAPAN:
6645 DAA_Coeff_Japan(j);
6646 retval = ixj_daa_write(j);
6647 break;
6648 default:
6649 retval = 1;
6650 break;
6651 }
6652 break;
6653 case IXJCTL_DAA_AGAIN:
6654 ixj_daa_cr4(j, arg | 0x02);
6655 break;
6656 case IXJCTL_PSTN_LINETEST:
6657 retval = ixj_linetest(j);
6658 break;
6659 case IXJCTL_VMWI:
6660 ixj_write_vmwi(j, arg);
6661 break;
6662 case IXJCTL_CID:
6663 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6664 retval = -EFAULT;
6665 j->ex.bits.caller_id = 0;
6666 break;
6667 case IXJCTL_WINK_DURATION:
6668 j->winktime = arg;
6669 break;
6670 case IXJCTL_PORT:
6671 if (arg)
6672 retval = ixj_set_port(j, arg);
6673 else
6674 retval = j->port;
6675 break;
6676 case IXJCTL_POTS_PSTN:
6677 retval = ixj_set_pots(j, arg);
6678 break;
6679 case PHONE_CAPABILITIES:
6680 add_caps(j);
6681 retval = j->caps;
6682 break;
6683 case PHONE_CAPABILITIES_LIST:
6684 add_caps(j);
6685 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6686 retval = -EFAULT;
6687 break;
6688 case PHONE_CAPABILITIES_CHECK:
6689 {
6690 struct phone_capability cap;
6691 if (copy_from_user(&cap, argp, sizeof(cap)))
6692 retval = -EFAULT;
6693 else {
6694 add_caps(j);
6695 retval = capabilities_check(j, &cap);
6696 }
6697 }
6698 break;
6699 case PHONE_PSTN_SET_STATE:
6700 daa_set_mode(j, arg);
6701 break;
6702 case PHONE_PSTN_GET_STATE:
6703 retval = j->daa_mode;
6704 j->ex.bits.pstn_ring = 0;
6705 break;
6706 case IXJCTL_SET_FILTER:
6707 if (copy_from_user(&jf, argp, sizeof(jf)))
6708 retval = -EFAULT;
6709 retval = ixj_init_filter(j, &jf);
6710 break;
6711 case IXJCTL_SET_FILTER_RAW:
6712 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6713 retval = -EFAULT;
6714 else
6715 retval = ixj_init_filter_raw(j, &jfr);
6716 break;
6717 case IXJCTL_GET_FILTER_HIST:
6718 if(arg<0||arg>3)
6719 retval = -EINVAL;
6720 else
6721 retval = j->filter_hist[arg];
6722 break;
6723 case IXJCTL_INIT_TONE:
6724 if (copy_from_user(&ti, argp, sizeof(ti)))
6725 retval = -EFAULT;
6726 else
6727 retval = ixj_init_tone(j, &ti);
6728 break;
6729 case IXJCTL_TONE_CADENCE:
6730 retval = ixj_build_cadence(j, argp);
6731 break;
6732 case IXJCTL_FILTER_CADENCE:
6733 retval = ixj_build_filter_cadence(j, argp);
6734 break;
6735 case IXJCTL_SIGCTL:
6736 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6737 retval = -EFAULT;
6738 break;
6739 }
6740 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6741 if(j->sigdef.event < 33) {
6742 raise = 1;
6743 for(mant = 0; mant < j->sigdef.event; mant++){
6744 raise *= 2;
6745 }
6746 if(j->sigdef.signal)
6747 j->ex_sig.bytes |= raise;
6748 else
6749 j->ex_sig.bytes &= (raise^0xffff);
6750 }
6751 break;
6752 case IXJCTL_INTERCOM_STOP:
6753 if(arg < 0 || arg >= IXJMAX)
6754 return -EINVAL;
6755 j->intercom = -1;
6756 ixj_record_stop(j);
6757 ixj_play_stop(j);
6758 idle(j);
6759 get_ixj(arg)->intercom = -1;
6760 ixj_record_stop(get_ixj(arg));
6761 ixj_play_stop(get_ixj(arg));
6762 idle(get_ixj(arg));
6763 break;
6764 case IXJCTL_INTERCOM_START:
6765 if(arg < 0 || arg >= IXJMAX)
6766 return -EINVAL;
6767 j->intercom = arg;
6768 ixj_record_start(j);
6769 ixj_play_start(j);
6770 get_ixj(arg)->intercom = board;
6771 ixj_play_start(get_ixj(arg));
6772 ixj_record_start(get_ixj(arg));
6773 break;
6774 }
6775 if (ixjdebug & 0x0040)
6776 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6777 clear_bit(board, &j->busyflags);
6778 return retval;
6779 }
6780
6781 static int ixj_fasync(int fd, struct file *file_p, int mode)
6782 {
6783 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6784
6785 return fasync_helper(fd, file_p, mode, &j->async_queue);
6786 }
6787
6788 struct file_operations ixj_fops =
6789 {
6790 .owner = THIS_MODULE,
6791 .read = ixj_enhanced_read,
6792 .write = ixj_enhanced_write,
6793 .poll = ixj_poll,
6794 .ioctl = ixj_ioctl,
6795 .release = ixj_release,
6796 .fasync = ixj_fasync
6797 };
6798
6799 static int ixj_linetest(IXJ *j)
6800 {
6801 unsigned long jifwait;
6802
6803 j->flags.pstncheck = 1; /* Testing */
6804 j->flags.pstn_present = 0; /* Assume the line is not there */
6805
6806 daa_int_read(j); /*Clear DAA Interrupt flags */
6807 /* */
6808 /* Hold all relays in the normally de-energized position. */
6809 /* */
6810
6811 j->pld_slicw.bits.rly1 = 0;
6812 j->pld_slicw.bits.rly2 = 0;
6813 j->pld_slicw.bits.rly3 = 0;
6814 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6815 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6816
6817 outb_p(j->pld_scrw.byte, j->XILINXbase);
6818 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6819 if (j->pld_slicr.bits.potspstn) {
6820 j->flags.pots_pstn = 1;
6821 j->flags.pots_correct = 0;
6822 LED_SetState(0x4, j);
6823 } else {
6824 j->flags.pots_pstn = 0;
6825 j->pld_slicw.bits.rly1 = 0;
6826 j->pld_slicw.bits.rly2 = 0;
6827 j->pld_slicw.bits.rly3 = 1;
6828 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6829 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6830
6831 outb_p(j->pld_scrw.byte, j->XILINXbase);
6832 daa_set_mode(j, SOP_PU_CONVERSATION);
6833 jifwait = jiffies + hertz;
6834 while (time_before(jiffies, jifwait)) {
6835 set_current_state(TASK_INTERRUPTIBLE);
6836 schedule_timeout(1);
6837 }
6838 daa_int_read(j);
6839 daa_set_mode(j, SOP_PU_RESET);
6840 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6841 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6842 LED_SetState(0x4, j);
6843 j->pld_slicw.bits.rly3 = 0;
6844 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6845 } else {
6846 j->flags.pots_correct = 1;
6847 LED_SetState(0x8, j);
6848 j->pld_slicw.bits.rly1 = 1;
6849 j->pld_slicw.bits.rly2 = 0;
6850 j->pld_slicw.bits.rly3 = 0;
6851 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6852 }
6853 }
6854 j->pld_slicw.bits.rly3 = 0;
6855 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6856 daa_set_mode(j, SOP_PU_CONVERSATION);
6857 jifwait = jiffies + hertz;
6858 while (time_before(jiffies, jifwait)) {
6859 set_current_state(TASK_INTERRUPTIBLE);
6860 schedule_timeout(1);
6861 }
6862 daa_int_read(j);
6863 daa_set_mode(j, SOP_PU_RESET);
6864 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6865 j->pstn_sleeptil = jiffies + (hertz / 4);
6866 j->flags.pstn_present = 1;
6867 } else {
6868 j->flags.pstn_present = 0;
6869 }
6870 if (j->flags.pstn_present) {
6871 if (j->flags.pots_correct) {
6872 LED_SetState(0xA, j);
6873 } else {
6874 LED_SetState(0x6, j);
6875 }
6876 } else {
6877 if (j->flags.pots_correct) {
6878 LED_SetState(0x9, j);
6879 } else {
6880 LED_SetState(0x5, j);
6881 }
6882 }
6883 j->flags.pstncheck = 0; /* Testing */
6884 return j->flags.pstn_present;
6885 }
6886
6887 static int ixj_selfprobe(IXJ *j)
6888 {
6889 unsigned short cmd;
6890 unsigned long jif;
6891 int cnt;
6892 BYTES bytes;
6893
6894 init_waitqueue_head(&j->poll_q);
6895 init_waitqueue_head(&j->read_q);
6896 init_waitqueue_head(&j->write_q);
6897
6898 while(atomic_read(&j->DSPWrite) > 0)
6899 atomic_dec(&j->DSPWrite);
6900 if (ixjdebug & 0x0002)
6901 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6902 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6903
6904 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6905 return -1;
6906 /* The read values of the SSR should be 0x00 for the IDLE command */
6907 if (j->ssr.low || j->ssr.high)
6908 return -1;
6909 if (ixjdebug & 0x0002)
6910 printk(KERN_INFO "Get Device ID Code\n");
6911 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6912 return -1;
6913 j->dsp.low = j->ssr.low;
6914 j->dsp.high = j->ssr.high;
6915 if (ixjdebug & 0x0002)
6916 printk(KERN_INFO "Get Device Version Code\n");
6917 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6918 return -1;
6919 j->ver.low = j->ssr.low;
6920 j->ver.high = j->ssr.high;
6921 if (!j->cardtype) {
6922 if (j->dsp.low == 0x21) {
6923 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6924 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6925 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6926 bytes.low = inb_p(j->XILINXbase + 0x02);
6927 if (bytes.low == bytes.high) /* Register is read only on */
6928 /* Internet PhoneJack Lite */
6929 {
6930 j->cardtype = QTI_PHONEJACK_LITE;
6931 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6932 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6933 return -1;
6934 }
6935 j->pld_slicw.pcib.e1 = 1;
6936 outb_p(j->pld_slicw.byte, j->XILINXbase);
6937 } else {
6938 j->cardtype = QTI_LINEJACK;
6939
6940 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6941 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6942 return -1;
6943 }
6944 }
6945 } else if (j->dsp.low == 0x22) {
6946 j->cardtype = QTI_PHONEJACK_PCI;
6947 request_region(j->XILINXbase, 4, "ixj control");
6948 j->pld_slicw.pcib.e1 = 1;
6949 outb_p(j->pld_slicw.byte, j->XILINXbase);
6950 } else
6951 j->cardtype = QTI_PHONEJACK;
6952 } else {
6953 switch (j->cardtype) {
6954 case QTI_PHONEJACK:
6955 if (!j->dsp.low != 0x20) {
6956 j->dsp.high = 0x80;
6957 j->dsp.low = 0x20;
6958 ixj_WriteDSPCommand(0x3800, j);
6959 j->ver.low = j->ssr.low;
6960 j->ver.high = j->ssr.high;
6961 }
6962 break;
6963 case QTI_LINEJACK:
6964 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6965 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6966 return -1;
6967 }
6968 break;
6969 case QTI_PHONEJACK_LITE:
6970 case QTI_PHONEJACK_PCI:
6971 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6972 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6973 return -1;
6974 }
6975 j->pld_slicw.pcib.e1 = 1;
6976 outb_p(j->pld_slicw.byte, j->XILINXbase);
6977 break;
6978 case QTI_PHONECARD:
6979 break;
6980 }
6981 }
6982 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6983 if (ixjdebug & 0x0002)
6984 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6985 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6986 return -1;
6987 if (ixjdebug & 0x0002)
6988 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6989 if (j->cardtype == QTI_PHONEJACK) {
6990 cmd = 0x9FF2;
6991 } else {
6992 cmd = 0x9FF5;
6993 }
6994 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6995 return -1;
6996 } else {
6997 if (set_base_frame(j, 30) != 30)
6998 return -1;
6999 if (ixjdebug & 0x0002)
7000 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
7001 if (j->cardtype == QTI_PHONECARD) {
7002 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
7003 return -1;
7004 }
7005 if (j->cardtype == QTI_LINEJACK) {
7006 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
7007 return -1;
7008 if (ixjdebug & 0x0002)
7009 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
7010 j->pld_clock.byte = 0;
7011 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
7012 }
7013 }
7014
7015 if (j->dsp.low == 0x20) {
7016 if (ixjdebug & 0x0002)
7017 printk(KERN_INFO "Configure GPIO pins\n");
7018 j->gpio.bytes.high = 0x09;
7019 /* bytes.low = 0xEF; 0xF7 */
7020 j->gpio.bits.gpio1 = 1;
7021 j->gpio.bits.gpio2 = 1;
7022 j->gpio.bits.gpio3 = 0;
7023 j->gpio.bits.gpio4 = 1;
7024 j->gpio.bits.gpio5 = 1;
7025 j->gpio.bits.gpio6 = 1;
7026 j->gpio.bits.gpio7 = 1;
7027 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
7028 if (ixjdebug & 0x0002)
7029 printk(KERN_INFO "Enable SLIC\n");
7030 j->gpio.bytes.high = 0x0B;
7031 j->gpio.bytes.low = 0x00;
7032 j->gpio.bits.gpio1 = 0;
7033 j->gpio.bits.gpio2 = 1;
7034 j->gpio.bits.gpio5 = 0;
7035 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
7036 j->port = PORT_POTS;
7037 } else {
7038 if (j->cardtype == QTI_LINEJACK) {
7039 LED_SetState(0x1, j);
7040 jif = jiffies + (hertz / 10);
7041 while (time_before(jiffies, jif)) {
7042 set_current_state(TASK_INTERRUPTIBLE);
7043 schedule_timeout(1);
7044 }
7045 LED_SetState(0x2, j);
7046 jif = jiffies + (hertz / 10);
7047 while (time_before(jiffies, jif)) {
7048 set_current_state(TASK_INTERRUPTIBLE);
7049 schedule_timeout(1);
7050 }
7051 LED_SetState(0x4, j);
7052 jif = jiffies + (hertz / 10);
7053 while (time_before(jiffies, jif)) {
7054 set_current_state(TASK_INTERRUPTIBLE);
7055 schedule_timeout(1);
7056 }
7057 LED_SetState(0x8, j);
7058 jif = jiffies + (hertz / 10);
7059 while (time_before(jiffies, jif)) {
7060 set_current_state(TASK_INTERRUPTIBLE);
7061 schedule_timeout(1);
7062 }
7063 LED_SetState(0x0, j);
7064 daa_get_version(j);
7065 if (ixjdebug & 0x0002)
7066 printk("Loading DAA Coefficients\n");
7067 DAA_Coeff_US(j);
7068 if (!ixj_daa_write(j)) {
7069 printk("DAA write failed on board %d\n", j->board);
7070 return -1;
7071 }
7072 if(!ixj_daa_cid_reset(j)) {
7073 printk("DAA CID reset failed on board %d\n", j->board);
7074 return -1;
7075 }
7076 j->flags.pots_correct = 0;
7077 j->flags.pstn_present = 0;
7078 ixj_linetest(j);
7079 if (j->flags.pots_correct) {
7080 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7081
7082 outb_p(j->pld_scrw.byte, j->XILINXbase);
7083 j->pld_slicw.bits.rly1 = 1;
7084 j->pld_slicw.bits.spken = 1;
7085 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7086 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7087 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7088 j->port = PORT_POTS;
7089 }
7090 ixj_set_port(j, PORT_PSTN);
7091 ixj_set_pots(j, 1);
7092 if (ixjdebug & 0x0002)
7093 printk(KERN_INFO "Enable Mixer\n");
7094 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
7095 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
7096
7097 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
7098 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
7099
7100 ixj_mixer(0x0480, j); /*FM Left mute */
7101 ixj_mixer(0x0580, j); /*FM Right mute */
7102
7103 ixj_mixer(0x0680, j); /*CD Left mute */
7104 ixj_mixer(0x0780, j); /*CD Right mute */
7105
7106 ixj_mixer(0x0880, j); /*Line Left mute */
7107 ixj_mixer(0x0980, j); /*Line Right mute */
7108
7109 ixj_mixer(0x0A80, j); /*Aux left mute */
7110 ixj_mixer(0x0B80, j); /*Aux right mute */
7111
7112 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
7113 ixj_mixer(0x0D80, j); /*Mono2 mute */
7114
7115 ixj_mixer(0x0E80, j); /*Mic mute */
7116
7117 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
7118
7119 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
7120 ixj_mixer(0x110C, j);
7121
7122
7123 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
7124 ixj_mixer(0x1401, j);
7125
7126 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
7127 ixj_mixer(0x1501, j);
7128
7129 ixj_mixer(0x1700, j); /*Clock select */
7130
7131 ixj_mixer(0x1800, j); /*ADC input from mixer */
7132
7133 ixj_mixer(0x1901, j); /*Mic gain 30db */
7134
7135 if (ixjdebug & 0x0002)
7136 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7137 j->cadence_f[4].state = 0;
7138 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
7139 j->cadence_f[4].off1 = 0;
7140 j->cadence_f[4].on2 = 0;
7141 j->cadence_f[4].off2 = 0;
7142 j->cadence_f[4].on3 = 0;
7143 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7144 j->pstn_last_rmr = jiffies;
7145
7146 } else {
7147 if (j->cardtype == QTI_PHONECARD) {
7148 ixj_WriteDSPCommand(0xCF07, j);
7149 ixj_WriteDSPCommand(0x00B0, j);
7150 ixj_set_port(j, PORT_SPEAKER);
7151 } else {
7152 ixj_set_port(j, PORT_POTS);
7153 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7154 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7155 }
7156 }
7157 }
7158
7159 j->intercom = -1;
7160 j->framesread = j->frameswritten = 0;
7161 j->read_wait = j->write_wait = 0;
7162 j->rxreadycheck = j->txreadycheck = 0;
7163
7164 /* initialise the DTMF prescale to a sensible value */
7165 if (j->cardtype == QTI_LINEJACK) {
7166 set_dtmf_prescale(j, 0x10);
7167 } else {
7168 set_dtmf_prescale(j, 0x40);
7169 }
7170 set_play_volume(j, 0x100);
7171 set_rec_volume(j, 0x100);
7172
7173 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7174 return -1;
7175 /* The read values of the SSR should be 0x00 for the IDLE command */
7176 if (j->ssr.low || j->ssr.high)
7177 return -1;
7178
7179 if (ixjdebug & 0x0002)
7180 printk(KERN_INFO "Enable Line Monitor\n");
7181
7182 if (ixjdebug & 0x0002)
7183 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7184
7185 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7186 return -1;
7187
7188 if (ixjdebug & 0x002)
7189 printk(KERN_INFO "Enable DTMF Detectors\n");
7190
7191 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7192 return -1;
7193
7194 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7195 return -1;
7196
7197 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7198
7199 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7200
7201 j->ex.bits.dtmf_ready = 0;
7202 j->dtmf_state = 0;
7203 j->dtmf_wp = j->dtmf_rp = 0;
7204 j->rec_mode = j->play_mode = -1;
7205 j->flags.ringing = 0;
7206 j->maxrings = MAXRINGS;
7207 j->ring_cadence = USA_RING_CADENCE;
7208 j->drybuffer = 0;
7209 j->winktime = 320;
7210 j->flags.dtmf_oob = 0;
7211 for (cnt = 0; cnt < 4; cnt++)
7212 j->cadence_f[cnt].enable = 0;
7213 /* must be a device on the specified address */
7214 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7215
7216 /* Set up the default signals for events */
7217 for (cnt = 0; cnt < 35; cnt++)
7218 j->ixj_signals[cnt] = SIGIO;
7219
7220 /* Set the excetion signal enable flags */
7221 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7222 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 =
7223 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;
7224 #ifdef IXJ_DYN_ALLOC
7225 j->fskdata = NULL;
7226 #endif
7227 j->fskdcnt = 0;
7228 j->cidcw_wait = 0;
7229
7230 /* Register with the Telephony for Linux subsystem */
7231 j->p.f_op = &ixj_fops;
7232 j->p.open = ixj_open;
7233 j->p.board = j->board;
7234 phone_register_device(&j->p, PHONE_UNIT_ANY);
7235
7236 ixj_init_timer(j);
7237 ixj_add_timer(j);
7238 return 0;
7239 }
7240
7241 /*
7242 * Exported service for pcmcia card handling
7243 */
7244
7245 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7246 {
7247 IXJ *j = ixj_alloc();
7248
7249 j->board = 0;
7250
7251 j->DSPbase = dsp;
7252 j->XILINXbase = xilinx;
7253 j->cardtype = QTI_PHONECARD;
7254 ixj_selfprobe(j);
7255 return j;
7256 }
7257
7258 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7259
7260 static int ixj_get_status_proc(char *buf)
7261 {
7262 int len;
7263 int cnt;
7264 IXJ *j;
7265 len = 0;
7266 len += sprintf(buf + len, "%s", ixj_c_rcsid);
7267 len += sprintf(buf + len, "\n%s", ixj_h_rcsid);
7268 len += sprintf(buf + len, "\n%s", ixjuser_h_rcsid);
7269 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7270 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7271 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7272 len += sprintf(buf + len, "\nUsing old telephony API");
7273 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7274
7275 for (cnt = 0; cnt < IXJMAX; cnt++) {
7276 j = get_ixj(cnt);
7277 if(j==NULL)
7278 continue;
7279 if (j->DSPbase) {
7280 len += sprintf(buf + len, "\nCard Num %d", cnt);
7281 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7282 if (j->cardtype != QTI_PHONEJACK)
7283 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7284 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7285 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7286 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7287 switch (j->cardtype) {
7288 case (QTI_PHONEJACK):
7289 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7290 break;
7291 case (QTI_LINEJACK):
7292 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7293 if (j->flags.g729_loaded)
7294 len += sprintf(buf + len, " w/G.729 A/B");
7295 len += sprintf(buf + len, " Country = %d", j->daa_country);
7296 break;
7297 case (QTI_PHONEJACK_LITE):
7298 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7299 if (j->flags.g729_loaded)
7300 len += sprintf(buf + len, " w/G.729 A/B");
7301 break;
7302 case (QTI_PHONEJACK_PCI):
7303 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7304 if (j->flags.g729_loaded)
7305 len += sprintf(buf + len, " w/G.729 A/B");
7306 break;
7307 case (QTI_PHONECARD):
7308 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7309 if (j->flags.g729_loaded)
7310 len += sprintf(buf + len, " w/G.729 A/B");
7311 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7312 if (!j->pccr1.bits.drf)
7313 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7314 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7315 break;
7316 default:
7317 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7318 break;
7319 }
7320 len += sprintf(buf + len, "\nReaders %d", j->readers);
7321 len += sprintf(buf + len, "\nWriters %d", j->writers);
7322 add_caps(j);
7323 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7324 if (j->dsp.low != 0x20)
7325 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7326 if (j->flags.cidsent)
7327 len += sprintf(buf + len, "\nCaller ID data sent");
7328 else
7329 len += sprintf(buf + len, "\nCaller ID data not sent");
7330
7331 len += sprintf(buf + len, "\nPlay CODEC ");
7332 switch (j->play_codec) {
7333 case G723_63:
7334 len += sprintf(buf + len, "G.723.1 6.3");
7335 break;
7336 case G723_53:
7337 len += sprintf(buf + len, "G.723.1 5.3");
7338 break;
7339 case TS85:
7340 len += sprintf(buf + len, "TrueSpeech 8.5");
7341 break;
7342 case TS48:
7343 len += sprintf(buf + len, "TrueSpeech 4.8");
7344 break;
7345 case TS41:
7346 len += sprintf(buf + len, "TrueSpeech 4.1");
7347 break;
7348 case G728:
7349 len += sprintf(buf + len, "G.728");
7350 break;
7351 case G729:
7352 len += sprintf(buf + len, "G.729");
7353 break;
7354 case G729B:
7355 len += sprintf(buf + len, "G.729B");
7356 break;
7357 case ULAW:
7358 len += sprintf(buf + len, "uLaw");
7359 break;
7360 case ALAW:
7361 len += sprintf(buf + len, "aLaw");
7362 break;
7363 case LINEAR16:
7364 len += sprintf(buf + len, "16 bit Linear");
7365 break;
7366 case LINEAR8:
7367 len += sprintf(buf + len, "8 bit Linear");
7368 break;
7369 case WSS:
7370 len += sprintf(buf + len, "Windows Sound System");
7371 break;
7372 default:
7373 len += sprintf(buf + len, "NO CODEC CHOSEN");
7374 break;
7375 }
7376 len += sprintf(buf + len, "\nRecord CODEC ");
7377 switch (j->rec_codec) {
7378 case G723_63:
7379 len += sprintf(buf + len, "G.723.1 6.3");
7380 break;
7381 case G723_53:
7382 len += sprintf(buf + len, "G.723.1 5.3");
7383 break;
7384 case TS85:
7385 len += sprintf(buf + len, "TrueSpeech 8.5");
7386 break;
7387 case TS48:
7388 len += sprintf(buf + len, "TrueSpeech 4.8");
7389 break;
7390 case TS41:
7391 len += sprintf(buf + len, "TrueSpeech 4.1");
7392 break;
7393 case G728:
7394 len += sprintf(buf + len, "G.728");
7395 break;
7396 case G729:
7397 len += sprintf(buf + len, "G.729");
7398 break;
7399 case G729B:
7400 len += sprintf(buf + len, "G.729B");
7401 break;
7402 case ULAW:
7403 len += sprintf(buf + len, "uLaw");
7404 break;
7405 case ALAW:
7406 len += sprintf(buf + len, "aLaw");
7407 break;
7408 case LINEAR16:
7409 len += sprintf(buf + len, "16 bit Linear");
7410 break;
7411 case LINEAR8:
7412 len += sprintf(buf + len, "8 bit Linear");
7413 break;
7414 case WSS:
7415 len += sprintf(buf + len, "Windows Sound System");
7416 break;
7417 default:
7418 len += sprintf(buf + len, "NO CODEC CHOSEN");
7419 break;
7420 }
7421 len += sprintf(buf + len, "\nAEC ");
7422 switch (j->aec_level) {
7423 case AEC_OFF:
7424 len += sprintf(buf + len, "Off");
7425 break;
7426 case AEC_LOW:
7427 len += sprintf(buf + len, "Low");
7428 break;
7429 case AEC_MED:
7430 len += sprintf(buf + len, "Med");
7431 break;
7432 case AEC_HIGH:
7433 len += sprintf(buf + len, "High");
7434 break;
7435 case AEC_AUTO:
7436 len += sprintf(buf + len, "Auto");
7437 break;
7438 case AEC_AGC:
7439 len += sprintf(buf + len, "AEC/AGC");
7440 break;
7441 default:
7442 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7443 break;
7444 }
7445
7446 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7447 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7448 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7449
7450 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7451
7452 if (j->cardtype == QTI_LINEJACK) {
7453 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7454 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7455 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7456 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7457 switch (j->daa_mode) {
7458 case SOP_PU_SLEEP:
7459 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7460 break;
7461 case SOP_PU_RINGING:
7462 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7463 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7464 break;
7465 case SOP_PU_CONVERSATION:
7466 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7467 break;
7468 case SOP_PU_PULSEDIALING:
7469 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7470 break;
7471 }
7472 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7473 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7474 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7475 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7476 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7477 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7478 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7479 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7480 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7481 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7482 }
7483 switch (j->port) {
7484 case PORT_POTS:
7485 len += sprintf(buf + len, "\nPort POTS");
7486 break;
7487 case PORT_PSTN:
7488 len += sprintf(buf + len, "\nPort PSTN");
7489 break;
7490 case PORT_SPEAKER:
7491 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7492 break;
7493 case PORT_HANDSET:
7494 len += sprintf(buf + len, "\nPort HANDSET");
7495 break;
7496 }
7497 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7498 len += sprintf(buf + len, "\nSLIC state ");
7499 switch (SLIC_GetState(j)) {
7500 case PLD_SLIC_STATE_OC:
7501 len += sprintf(buf + len, "OC");
7502 break;
7503 case PLD_SLIC_STATE_RINGING:
7504 len += sprintf(buf + len, "RINGING");
7505 break;
7506 case PLD_SLIC_STATE_ACTIVE:
7507 len += sprintf(buf + len, "ACTIVE");
7508 break;
7509 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7510 len += sprintf(buf + len, "OHT");
7511 break;
7512 case PLD_SLIC_STATE_TIPOPEN:
7513 len += sprintf(buf + len, "TIPOPEN");
7514 break;
7515 case PLD_SLIC_STATE_STANDBY:
7516 len += sprintf(buf + len, "STANDBY");
7517 break;
7518 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7519 len += sprintf(buf + len, "APR");
7520 break;
7521 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7522 len += sprintf(buf + len, "OHTPR");
7523 break;
7524 default:
7525 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7526 break;
7527 }
7528 }
7529 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7530 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7531 #ifdef PERFMON_STATS
7532 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7533 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7534 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7535 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7536 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7537 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7538 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7539 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7540 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7541 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7542 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7543 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7544 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7545 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7546
7547 #endif
7548 len += sprintf(buf + len, "\n");
7549 }
7550 }
7551 return len;
7552 }
7553
7554 static int ixj_read_proc(char *page, char **start, off_t off,
7555 int count, int *eof, void *data)
7556 {
7557 int len = ixj_get_status_proc(page);
7558 if (len <= off+count) *eof = 1;
7559 *start = page + off;
7560 len -= off;
7561 if (len>count) len = count;
7562 if (len<0) len = 0;
7563 return len;
7564 }
7565
7566
7567 static void cleanup(void)
7568 {
7569 int cnt;
7570 IXJ *j;
7571
7572 for (cnt = 0; cnt < IXJMAX; cnt++) {
7573 j = get_ixj(cnt);
7574 if(j != NULL && j->DSPbase) {
7575 if (ixjdebug & 0x0002)
7576 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7577 del_timer(&j->timer);
7578 if (j->cardtype == QTI_LINEJACK) {
7579 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7580
7581 outb_p(j->pld_scrw.byte, j->XILINXbase);
7582 j->pld_slicw.bits.rly1 = 0;
7583 j->pld_slicw.bits.rly2 = 0;
7584 j->pld_slicw.bits.rly3 = 0;
7585 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7586 LED_SetState(0x0, j);
7587 if (ixjdebug & 0x0002)
7588 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7589 release_region(j->XILINXbase, 8);
7590 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7591 if (ixjdebug & 0x0002)
7592 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7593 release_region(j->XILINXbase, 4);
7594 }
7595 if (j->read_buffer)
7596 kfree(j->read_buffer);
7597 if (j->write_buffer)
7598 kfree(j->write_buffer);
7599 if (j->dev)
7600 pnp_device_detach(j->dev);
7601 if (ixjdebug & 0x0002)
7602 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7603 phone_unregister_device(&j->p);
7604 if (ixjdebug & 0x0002)
7605 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7606 release_region(j->DSPbase, 16);
7607 #ifdef IXJ_DYN_ALLOC
7608 if (ixjdebug & 0x0002)
7609 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7610 kfree(j);
7611 ixj[cnt] = NULL;
7612 #endif
7613 }
7614 }
7615 if (ixjdebug & 0x0002)
7616 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7617 remove_proc_entry ("ixj", NULL);
7618 }
7619
7620 /* Typedefs */
7621 typedef struct {
7622 BYTE length;
7623 DWORD bits;
7624 } DATABLOCK;
7625
7626 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7627 {
7628 lastLCC = lastLCC & 0xfb;
7629 lastLCC = lastLCC | (byData ? 4 : 0);
7630 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7631
7632 mdelay(1);
7633 lastLCC = lastLCC | 0x01;
7634 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7635
7636 byData = byData << 1;
7637 lastLCC = lastLCC & 0xfe;
7638 mdelay(1);
7639 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7640
7641 }
7642
7643 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7644 {
7645 mdelay(1);
7646 lastLCC = lastLCC | 0x01;
7647 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7648
7649 lastLCC = lastLCC & 0xfe;
7650 mdelay(1);
7651 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7652
7653 return ((inb(wEEPROMAddress) >> 3) & 1);
7654 }
7655
7656 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7657 {
7658 BYTE lastLCC;
7659 WORD wEEPROMAddress = wAddress + 3;
7660 DWORD i;
7661 BYTE byResult;
7662 *pwResult = 0;
7663 lastLCC = inb(wEEPROMAddress);
7664 lastLCC = lastLCC | 0x02;
7665 lastLCC = lastLCC & 0xfe;
7666 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7667
7668 mdelay(1); /* delay */
7669
7670 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7671 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7672 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7673 for (i = 0; i < 8; i++) {
7674 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7675 wLoc <<= 1;
7676 }
7677
7678 for (i = 0; i < 16; i++) {
7679 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7680 *pwResult = (*pwResult << 1) | byResult;
7681 }
7682
7683 mdelay(1); /* another delay */
7684
7685 lastLCC = lastLCC & 0xfd;
7686 outb(lastLCC, wEEPROMAddress); /* negate CS */
7687
7688 return 0;
7689 }
7690
7691 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7692 {
7693 WORD wLo, wHi;
7694 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7695 return 0;
7696 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7697 return 0;
7698 return (((DWORD) wHi << 16) | wLo);
7699 }
7700
7701 static int dspio[IXJMAX + 1] =
7702 {
7703 0,
7704 };
7705 static int xio[IXJMAX + 1] =
7706 {
7707 0,
7708 };
7709
7710 MODULE_PARM(dspio, "1-" __MODULE_STRING(IXJMAX) "i");
7711 MODULE_PARM(xio, "1-" __MODULE_STRING(IXJMAX) "i");
7712 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7713 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7714 MODULE_LICENSE("GPL");
7715
7716 static void __exit ixj_exit(void)
7717 {
7718 cleanup();
7719 }
7720
7721 static IXJ *new_ixj(unsigned long port)
7722 {
7723 IXJ *res;
7724 if (!request_region(port, 16, "ixj DSP")) {
7725 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7726 return NULL;
7727 }
7728 res = ixj_alloc();
7729 if (!res) {
7730 release_region(port, 16);
7731 printk(KERN_INFO "ixj: out of memory\n");
7732 return NULL;
7733 }
7734 res->DSPbase = port;
7735 return res;
7736 }
7737
7738 int __init ixj_probe_isapnp(int *cnt)
7739 {
7740 int probe = 0;
7741 int func = 0x110;
7742 struct pnp_dev *dev = NULL, *old_dev = NULL;
7743
7744 while (1) {
7745 do {
7746 IXJ *j;
7747 int result;
7748
7749 old_dev = dev;
7750 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7751 ISAPNP_FUNCTION(func), old_dev);
7752 if (!dev || !dev->card)
7753 break;
7754 result = pnp_device_attach(dev);
7755 if (result < 0) {
7756 printk("pnp attach failed %d \n", result);
7757 break;
7758 }
7759 if (pnp_activate_dev(dev) < 0) {
7760 printk("pnp activate failed (out of resources?)\n");
7761 pnp_device_detach(dev);
7762 return -ENOMEM;
7763 }
7764
7765 if (!pnp_port_valid(dev, 0)) {
7766 pnp_device_detach(dev);
7767 return -ENODEV;
7768 }
7769
7770 j = new_ixj(pnp_port_start(dev, 0));
7771 if (!j)
7772 break;
7773
7774 if (func != 0x110)
7775 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7776
7777 switch (func) {
7778 case (0x110):
7779 j->cardtype = QTI_PHONEJACK;
7780 break;
7781 case (0x310):
7782 j->cardtype = QTI_LINEJACK;
7783 break;
7784 case (0x410):
7785 j->cardtype = QTI_PHONEJACK_LITE;
7786 break;
7787 }
7788 j->board = *cnt;
7789 probe = ixj_selfprobe(j);
7790 if(!probe) {
7791 j->serial = dev->card->serial;
7792 j->dev = dev;
7793 switch (func) {
7794 case 0x110:
7795 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7796 break;
7797 case 0x310:
7798 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7799 break;
7800 case 0x410:
7801 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7802 break;
7803 }
7804 }
7805 ++*cnt;
7806 } while (dev);
7807 if (func == 0x410)
7808 break;
7809 if (func == 0x310)
7810 func = 0x410;
7811 if (func == 0x110)
7812 func = 0x310;
7813 dev = NULL;
7814 }
7815 return probe;
7816 }
7817
7818 int __init ixj_probe_isa(int *cnt)
7819 {
7820 int i, probe;
7821
7822 /* Use passed parameters for older kernels without PnP */
7823 for (i = 0; i < IXJMAX; i++) {
7824 if (dspio[i]) {
7825 IXJ *j = new_ixj(dspio[i]);
7826
7827 if (!j)
7828 break;
7829
7830 j->XILINXbase = xio[i];
7831 j->cardtype = 0;
7832
7833 j->board = *cnt;
7834 probe = ixj_selfprobe(j);
7835 j->dev = NULL;
7836 ++*cnt;
7837 }
7838 }
7839 return 0;
7840 }
7841
7842 int __init ixj_probe_pci(int *cnt)
7843 {
7844 struct pci_dev *pci = NULL;
7845 int i, probe = 0;
7846 IXJ *j = NULL;
7847
7848 for (i = 0; i < IXJMAX - *cnt; i++) {
7849 pci = pci_find_device(0x15E2, 0x0500, pci);
7850 if (!pci)
7851 break;
7852
7853 if (pci_enable_device(pci))
7854 break;
7855 j = new_ixj(pci_resource_start(pci, 0));
7856 if (!j)
7857 break;
7858
7859 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7860 j->XILINXbase = j->DSPbase + 0x10;
7861 j->cardtype = QTI_PHONEJACK_PCI;
7862 j->board = *cnt;
7863 probe = ixj_selfprobe(j);
7864 if (!probe)
7865 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7866 ++*cnt;
7867 }
7868 return probe;
7869 }
7870
7871 static int __init ixj_init(void)
7872 {
7873 int cnt = 0;
7874 int probe = 0;
7875
7876 cnt = 0;
7877
7878 /* These might be no-ops, see above. */
7879 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7880 return probe;
7881 }
7882 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7883 return probe;
7884 }
7885 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7886 return probe;
7887 }
7888 printk("%s\n", ixj_c_rcsid);
7889 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7890 return probe;
7891 }
7892
7893 module_init(ixj_init);
7894 module_exit(ixj_exit);
7895
7896 static void DAA_Coeff_US(IXJ *j)
7897 {
7898 int i;
7899
7900 j->daa_country = DAA_US;
7901 /*----------------------------------------------- */
7902 /* CAO */
7903 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7904 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7905 }
7906
7907 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7908 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7909 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7910 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7911 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7912 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7913 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7914 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7915 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7916 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7917 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7918 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7919 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7920 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7921 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7922 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7923 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7924 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7925 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7926 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7927 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7928 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7929 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7930 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7931 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7932 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7933 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7934 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7935 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7936 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7937 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7938 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7939 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7940 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7941 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7942 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7943 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7944 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7945 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7946 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7947 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7948 /* Bytes for AR-filter (09): 52,D3,11,42 */
7949 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7950 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7951 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7952 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7953 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7954 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7955 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7956 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7957 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7958 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7959 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7960 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7961 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7962 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7963 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7964 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7965 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7966 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7967 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7968 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7969 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7970 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7971 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7972 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7973 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7974 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7975 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7976 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7977 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7978 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7979 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7980 /* ; (10K, 0.68uF) */
7981 /* */
7982 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7983 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7984 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7985 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7986 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7987 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7988 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7989 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7990 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7991 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7992 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7993 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7994 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7995 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7996 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7997 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7998 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7999 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8000
8001 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8002 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8003 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8004 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8005 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8006
8007 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8008 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
8009 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
8010 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
8011 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
8012 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
8013 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
8014 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
8015 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
8016 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8017 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
8018 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
8019 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
8020 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
8021 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
8022 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
8023 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
8024 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
8025 /* */
8026 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8027 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
8028 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
8029 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
8030 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
8031
8032 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8033 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8034 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8035 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8036 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8037 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8038 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8039 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8040 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8041 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8042 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8043 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8044 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8045 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8046 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8047 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8048 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8049 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8050 /* */
8051 /* ;CR Registers */
8052 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
8053 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8054 /* Config. Reg. 1 (dialing) (cr1):05 */
8055 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8056 /* Config. Reg. 2 (caller ID) (cr2):04 */
8057 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8058 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
8059 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8060 /* Config. Reg. 4 (analog gain) (cr4):02 */
8061 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8062 /* Config. Reg. 5 (Version) (cr5):02 */
8063 /* Config. Reg. 6 (Reserved) (cr6):00 */
8064 /* Config. Reg. 7 (Reserved) (cr7):00 */
8065 /* */
8066 /* ;xr Registers */
8067 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8068
8069 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8070 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
8071
8072 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
8073 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8074 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8075 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
8076 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
8077 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8078
8079 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8080 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8081 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8082 /* Ext. Reg. 6 (Power State) (xr6):00 */
8083 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8084 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8085 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8086 /* */
8087 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8088 /* 12,33,5A,C3 ; 770 Hz */
8089 /* 13,3C,5B,32 ; 852 Hz */
8090 /* 1D,1B,5C,CC ; 941 Hz */
8091
8092 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8093 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8094 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8095 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8096 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8097 /* EC,1D,52,22 ; 1336 Hz */
8098 /* AA,AC,51,D2 ; 1477 Hz */
8099 /* 9B,3B,51,25 ; 1633 Hz */
8100 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8101 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8102 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8103 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8104 }
8105
8106 static void DAA_Coeff_UK(IXJ *j)
8107 {
8108 int i;
8109
8110 j->daa_country = DAA_UK;
8111 /*----------------------------------------------- */
8112 /* CAO */
8113 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8114 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8115 }
8116
8117 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8118 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8119 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8120 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8121 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8122 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8123 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8124 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8125 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8126 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8127 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8128 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8129 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8130 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8131 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8132 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8133 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8134 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8135 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
8136 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8137 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8138 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8139 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8140 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8141 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8142 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8143 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8144 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8145 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8146 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8147 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8148 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8149 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8150 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8151 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8152 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8153 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8154 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8155 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8156 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8157 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8158 /* Bytes for AR-filter (09): E2,27,10,D6 */
8159 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8160 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8161 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8162 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8163 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8164 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8165 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8166 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8167 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8168 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8169 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8170 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8171 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8172 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8173 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8174 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8175 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8176 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8177 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8178 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8179 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8180 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8181 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8182 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8183 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8184 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8185 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8186 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8187 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8188 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8189 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8190 /* ; idle */
8191 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8192 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8193 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8194 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8195 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8196 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8197 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8198 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8199 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8200 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8201 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8202 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8203 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8204 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8205 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8206 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8207 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8208 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8209 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8210 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8211 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8212 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8213 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8214 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8215 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8216 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8217 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8218 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8219 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8220 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8221 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8222 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8223 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8224 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8225 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8226 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8227 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8228 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8229 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8230 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8231 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8232 /* ;CR Registers */
8233 /* Config. Reg. 0 (filters) (cr0):FF */
8234 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8235 /* Config. Reg. 1 (dialing) (cr1):05 */
8236 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8237 /* Config. Reg. 2 (caller ID) (cr2):04 */
8238 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8239 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8240 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8241 /* Config. Reg. 4 (analog gain) (cr4):02 */
8242 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8243 /* Config. Reg. 5 (Version) (cr5):02 */
8244 /* Config. Reg. 6 (Reserved) (cr6):00 */
8245 /* Config. Reg. 7 (Reserved) (cr7):00 */
8246 /* ;xr Registers */
8247 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8248
8249 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8250 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8251
8252 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8253 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8254
8255 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8256 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8257 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8258 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8259 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8260 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8261 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8262 /* Ext. Reg. 6 (Power State) (xr6):00 */
8263 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8264 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8265 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8266 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8267 /* 12,33,5A,C3 ; 770 Hz */
8268 /* 13,3C,5B,32 ; 852 Hz */
8269 /* 1D,1B,5C,CC ; 941 Hz */
8270
8271 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8272 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8273 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8274 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8275 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8276 /* EC,1D,52,22 ; 1336 Hz */
8277 /* AA,AC,51,D2 ; 1477 Hz */
8278 /* 9B,3B,51,25 ; 1633 Hz */
8279 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8280 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8281 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8282 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8283 }
8284
8285
8286 static void DAA_Coeff_France(IXJ *j)
8287 {
8288 int i;
8289
8290 j->daa_country = DAA_FRANCE;
8291 /*----------------------------------------------- */
8292 /* CAO */
8293 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8294 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8295 }
8296
8297 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8298 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8299 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8300 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8301 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8302 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8303 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8304 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8305 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8306 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8307 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8308 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8309 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8310 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8311 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8312 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8313 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8314 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8315 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8316 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8317 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8318 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8319 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8320 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8321 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8322 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8323 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8324 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8325 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8326 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8327 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8328 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8329 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8330 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8331 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8332 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8333 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8334 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8335 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8336 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8337 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8338 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8339 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8340 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8341 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8342 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8343 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8344 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8345 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8346 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8347 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8348 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8349 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8350 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8351 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8352 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8353 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8354 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8355 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8356 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8357 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8358 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8359 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8360 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8361 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8362 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8363 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8364 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8365 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8366 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8367 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8368 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8369 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8370 /* ; idle */
8371 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8372 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8373 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8374 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8375 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8376 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8377 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8378 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8379 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8380 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8381 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8382 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8383 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8384 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8385 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8386 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8387 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8388 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8389 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8390 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8391 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8392 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8393 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8394 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8395 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8396 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8397 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8398 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8399 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8400 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8401 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8402 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8403 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8404 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8405 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8406 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8407 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8408 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8409 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8410 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8411 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8412 /* ;CR Registers */
8413 /* Config. Reg. 0 (filters) (cr0):FF */
8414 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8415 /* Config. Reg. 1 (dialing) (cr1):05 */
8416 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8417 /* Config. Reg. 2 (caller ID) (cr2):04 */
8418 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8419 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8420 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8421 /* Config. Reg. 4 (analog gain) (cr4):02 */
8422 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8423 /* Config. Reg. 5 (Version) (cr5):02 */
8424 /* Config. Reg. 6 (Reserved) (cr6):00 */
8425 /* Config. Reg. 7 (Reserved) (cr7):00 */
8426 /* ;xr Registers */
8427 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8428
8429 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8430 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8431
8432 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8433 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8434
8435 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8436 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8437 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8438 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8439 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8440 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8441 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8442 /* Ext. Reg. 6 (Power State) (xr6):00 */
8443 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8444 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8445 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8446 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8447 /* 12,33,5A,C3 ; 770 Hz */
8448 /* 13,3C,5B,32 ; 852 Hz */
8449 /* 1D,1B,5C,CC ; 941 Hz */
8450
8451 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8452 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8453 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8454 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8455 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8456 /* EC,1D,52,22 ; 1336 Hz */
8457 /* AA,AC,51,D2 ; 1477 Hz */
8458 /* 9B,3B,51,25 ; 1633 Hz */
8459 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8460 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8461 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8462 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8463 }
8464
8465
8466 static void DAA_Coeff_Germany(IXJ *j)
8467 {
8468 int i;
8469
8470 j->daa_country = DAA_GERMANY;
8471 /*----------------------------------------------- */
8472 /* CAO */
8473 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8474 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8475 }
8476
8477 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8478 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8479 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8480 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8481 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8482 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8483 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8484 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8485 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8486 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8487 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8488 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8489 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8490 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8491 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8492 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8493 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8494 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8495 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8496 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8497 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8498 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8499 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8500 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8501 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8502 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8503 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8504 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8505 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8506 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8507 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8508 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8509 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8510 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8511 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8512 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8513 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8514 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8515 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8516 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8517 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8518 /* Bytes for AR-filter (09): 72,42,13,4B */
8519 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8520 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8521 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8522 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8523 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8524 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8525 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8526 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8527 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8528 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8529 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8530 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8531 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8532 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8533 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8534 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8535 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8536 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8537 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8538 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8539 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8540 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8541 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8542 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8543 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8544 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8545 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8546 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8547 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8548 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8549 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8550 /* ; (10K, 0.68uF) */
8551 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8552 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8553 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8554 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8555 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8556 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8557 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8558 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8559 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8560 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8561 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8562 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8563 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8564 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8565 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8566 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8567 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8568 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8569 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8570 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8571 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8572 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8573 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8574 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8575 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8576 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8577 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8578 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8579 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8580 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8581 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8582 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8583 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8584 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8585 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8586 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8587 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8588 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8589 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8590 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8591 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8592 /* ;CR Registers */
8593 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8594 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8595 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8596 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8597 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8598 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8599 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8600 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8601 /* Config. Reg. 4 (analog gain) (cr4):02 */
8602 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8603 /* Config. Reg. 5 (Version) (cr5):02 */
8604 /* Config. Reg. 6 (Reserved) (cr6):00 */
8605 /* Config. Reg. 7 (Reserved) (cr7):00 */
8606 /* ;xr Registers */
8607 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8608
8609 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8610 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8611
8612 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8613 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8614
8615 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8616 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8617 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8618 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8619 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8620 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8621 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8622 /* Ext. Reg. 6 (Power State) (xr6):00 */
8623 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8624 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8625 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8626 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8627 /* 12,33,5A,C3 ; 770 Hz */
8628 /* 13,3C,5B,32 ; 852 Hz */
8629 /* 1D,1B,5C,CC ; 941 Hz */
8630
8631 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8632 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8633 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8634 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8635 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8636 /* EC,1D,52,22 ; 1336 Hz */
8637 /* AA,AC,51,D2 ; 1477 Hz */
8638 /* 9B,3B,51,25 ; 1633 Hz */
8639 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8640 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8641 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8642 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8643 }
8644
8645
8646 static void DAA_Coeff_Australia(IXJ *j)
8647 {
8648 int i;
8649
8650 j->daa_country = DAA_AUSTRALIA;
8651 /*----------------------------------------------- */
8652 /* CAO */
8653 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8654 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8655 }
8656
8657 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8658 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8659 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8660 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8661 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8662 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8663 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8664 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8665 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8666 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8667 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8668 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8669 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8670 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8671 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8672 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8673 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8674 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8675 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8676 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8677 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8678 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8679 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8680 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8681 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8682 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8683 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8684 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8685 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8686 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8687 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8688 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8689 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8690 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8691 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8692 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8693 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8694 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8695 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8696 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8697 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8698 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8699 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8700 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8701 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8702 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8703 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8704 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8705 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8706 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8707 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8708 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8709 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8710 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8711 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8712 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8713 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8714 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8715 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8716 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8717 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8718 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8719 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8720 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8721 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8722 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8723 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8724 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8725 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8726 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8727 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8728 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8729 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8730 /* ; idle */
8731 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8732 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8733 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8734 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8735 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8736 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8737 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8738 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8739 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8740 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8741 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8742 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8743 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8744 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8745 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8746 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8747 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8748 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8749 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8750 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8751 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8752 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8753 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8754 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8755 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8756 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8757 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8758 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8759 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8760 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8761 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8762 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8763 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8764 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8765 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8766 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8767 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8768 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8769 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8770 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8771 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8772 /* ;CR Registers */
8773 /* Config. Reg. 0 (filters) (cr0):FF */
8774 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8775 /* Config. Reg. 1 (dialing) (cr1):05 */
8776 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8777 /* Config. Reg. 2 (caller ID) (cr2):04 */
8778 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8779 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8780 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8781 /* Config. Reg. 4 (analog gain) (cr4):02 */
8782 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8783 /* Config. Reg. 5 (Version) (cr5):02 */
8784 /* Config. Reg. 6 (Reserved) (cr6):00 */
8785 /* Config. Reg. 7 (Reserved) (cr7):00 */
8786 /* ;xr Registers */
8787 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8788
8789 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8790 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8791
8792 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8793 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8794
8795 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8796 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8797 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8798 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8799 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8800 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8801 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8802 /* Ext. Reg. 6 (Power State) (xr6):00 */
8803 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8804 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8805 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8806
8807 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8808 /* 12,33,5A,C3 ; 770 Hz */
8809 /* 13,3C,5B,32 ; 852 Hz */
8810 /* 1D,1B,5C,CC ; 941 Hz */
8811 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8812 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8813 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8814 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8815
8816 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8817 /* EC,1D,52,22 ; 1336 Hz */
8818 /* AA,AC,51,D2 ; 1477 Hz */
8819 /* 9B,3B,51,25 ; 1633 Hz */
8820 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8821 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8822 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8823 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8824 }
8825
8826 static void DAA_Coeff_Japan(IXJ *j)
8827 {
8828 int i;
8829
8830 j->daa_country = DAA_JAPAN;
8831 /*----------------------------------------------- */
8832 /* CAO */
8833 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8834 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8835 }
8836
8837 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8838 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8839 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8840 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8841 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8842 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8843 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8844 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8845 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8846 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8847 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8848 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8849 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8850 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8851 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8852 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8853 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8854 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8855 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8856 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8857 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8858 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8859 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8860 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8861 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8862 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8863 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8864 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8865 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8866 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8867 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8868 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8869 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8870 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8871 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8872 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8873 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8874 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8875 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8876 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8877 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8878 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8879 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8880 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8881 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8882 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8883 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8884 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8885 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8886 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8887 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8888 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8889 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8890 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8891 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8892 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8893 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8894 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8895 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8896 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8897 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8898 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8899 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8900 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8901 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8902 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8903 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8904 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8905 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8906 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8907 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8908 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8909 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8910 /* ; idle */
8911 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8912 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8913 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8914 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8915 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8916 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8917 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8918 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8919 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8920 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8921 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8922 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8923 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8924 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8925 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8926 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8927 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8928 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8929 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8930 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8931 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8932 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8933 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8934 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8935 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8936 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8937 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8938 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8939 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8940 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8941 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8942 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8943 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8944 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8945 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8946 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8947 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8948 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8949 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8950 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8951 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8952 /* ;CR Registers */
8953 /* Config. Reg. 0 (filters) (cr0):FF */
8954 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8955 /* Config. Reg. 1 (dialing) (cr1):05 */
8956 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8957 /* Config. Reg. 2 (caller ID) (cr2):04 */
8958 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8959 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8960 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8961 /* Config. Reg. 4 (analog gain) (cr4):02 */
8962 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8963 /* Config. Reg. 5 (Version) (cr5):02 */
8964 /* Config. Reg. 6 (Reserved) (cr6):00 */
8965 /* Config. Reg. 7 (Reserved) (cr7):00 */
8966 /* ;xr Registers */
8967 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8968
8969 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8970 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8971
8972 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8973 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8974
8975 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8976 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8977 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8978 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8979 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8980 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8981 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8982 /* Ext. Reg. 6 (Power State) (xr6):00 */
8983 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8984 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8985 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8986 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8987 /* 12,33,5A,C3 ; 770 Hz */
8988 /* 13,3C,5B,32 ; 852 Hz */
8989 /* 1D,1B,5C,CC ; 941 Hz */
8990
8991 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8992 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8993 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8994 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8995 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8996 /* EC,1D,52,22 ; 1336 Hz */
8997 /* AA,AC,51,D2 ; 1477 Hz */
8998 /* 9B,3B,51,25 ; 1633 Hz */
8999 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
9000 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
9001 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
9002 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
9003 }
9004
9005 static s16 tone_table[][19] =
9006 {
9007 { /* f20_50[] 11 */
9008 32538, /* A1 = 1.985962 */
9009 -32325, /* A2 = -0.986511 */
9010 -343, /* B2 = -0.010493 */
9011 0, /* B1 = 0 */
9012 343, /* B0 = 0.010493 */
9013 32619, /* A1 = 1.990906 */
9014 -32520, /* A2 = -0.992462 */
9015 19179, /* B2 = 0.585327 */
9016 -19178, /* B1 = -1.170593 */
9017 19179, /* B0 = 0.585327 */
9018 32723, /* A1 = 1.997314 */
9019 -32686, /* A2 = -0.997528 */
9020 9973, /* B2 = 0.304352 */
9021 -9955, /* B1 = -0.607605 */
9022 9973, /* B0 = 0.304352 */
9023 7, /* Internal filter scaling */
9024 159, /* Minimum in-band energy threshold */
9025 21, /* 21/32 in-band to broad-band ratio */
9026 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9027 },
9028 { /* f133_200[] 12 */
9029 32072, /* A1 = 1.95752 */
9030 -31896, /* A2 = -0.973419 */
9031 -435, /* B2 = -0.013294 */
9032 0, /* B1 = 0 */
9033 435, /* B0 = 0.013294 */
9034 32188, /* A1 = 1.9646 */
9035 -32400, /* A2 = -0.98877 */
9036 15139, /* B2 = 0.462036 */
9037 -14882, /* B1 = -0.908356 */
9038 15139, /* B0 = 0.462036 */
9039 32473, /* A1 = 1.981995 */
9040 -32524, /* A2 = -0.992584 */
9041 23200, /* B2 = 0.708008 */
9042 -23113, /* B1 = -1.410706 */
9043 23200, /* B0 = 0.708008 */
9044 7, /* Internal filter scaling */
9045 159, /* Minimum in-band energy threshold */
9046 21, /* 21/32 in-band to broad-band ratio */
9047 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9048 },
9049 { /* f300 13 */
9050 31769, /* A1 = -1.939026 */
9051 -32584, /* A2 = 0.994385 */
9052 -475, /* B2 = -0.014522 */
9053 0, /* B1 = 0.000000 */
9054 475, /* B0 = 0.014522 */
9055 31789, /* A1 = -1.940247 */
9056 -32679, /* A2 = 0.997284 */
9057 17280, /* B2 = 0.527344 */
9058 -16865, /* B1 = -1.029358 */
9059 17280, /* B0 = 0.527344 */
9060 31841, /* A1 = -1.943481 */
9061 -32681, /* A2 = 0.997345 */
9062 543, /* B2 = 0.016579 */
9063 -525, /* B1 = -0.032097 */
9064 543, /* B0 = 0.016579 */
9065 5, /* Internal filter scaling */
9066 159, /* Minimum in-band energy threshold */
9067 21, /* 21/32 in-band to broad-band ratio */
9068 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9069 },
9070 { /* f300_420[] 14 */
9071 30750, /* A1 = 1.876892 */
9072 -31212, /* A2 = -0.952515 */
9073 -804, /* B2 = -0.024541 */
9074 0, /* B1 = 0 */
9075 804, /* B0 = 0.024541 */
9076 30686, /* A1 = 1.872925 */
9077 -32145, /* A2 = -0.980988 */
9078 14747, /* B2 = 0.450043 */
9079 -13703, /* B1 = -0.836395 */
9080 14747, /* B0 = 0.450043 */
9081 31651, /* A1 = 1.931824 */
9082 -32321, /* A2 = -0.986389 */
9083 24425, /* B2 = 0.745422 */
9084 -23914, /* B1 = -1.459595 */
9085 24427, /* B0 = 0.745483 */
9086 7, /* Internal filter scaling */
9087 159, /* Minimum in-band energy threshold */
9088 21, /* 21/32 in-band to broad-band ratio */
9089 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9090 },
9091 { /* f330 15 */
9092 31613, /* A1 = -1.929565 */
9093 -32646, /* A2 = 0.996277 */
9094 -185, /* B2 = -0.005657 */
9095 0, /* B1 = 0.000000 */
9096 185, /* B0 = 0.005657 */
9097 31620, /* A1 = -1.929932 */
9098 -32713, /* A2 = 0.998352 */
9099 19253, /* B2 = 0.587585 */
9100 -18566, /* B1 = -1.133179 */
9101 19253, /* B0 = 0.587585 */
9102 31674, /* A1 = -1.933228 */
9103 -32715, /* A2 = 0.998413 */
9104 2575, /* B2 = 0.078590 */
9105 -2495, /* B1 = -0.152283 */
9106 2575, /* B0 = 0.078590 */
9107 5, /* Internal filter scaling */
9108 159, /* Minimum in-band energy threshold */
9109 21, /* 21/32 in-band to broad-band ratio */
9110 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9111 },
9112 { /* f300_425[] 16 */
9113 30741, /* A1 = 1.876282 */
9114 -31475, /* A2 = -0.960541 */
9115 -703, /* B2 = -0.021484 */
9116 0, /* B1 = 0 */
9117 703, /* B0 = 0.021484 */
9118 30688, /* A1 = 1.873047 */
9119 -32248, /* A2 = -0.984161 */
9120 14542, /* B2 = 0.443787 */
9121 -13523, /* B1 = -0.825439 */
9122 14542, /* B0 = 0.443817 */
9123 31494, /* A1 = 1.922302 */
9124 -32366, /* A2 = -0.987762 */
9125 21577, /* B2 = 0.658508 */
9126 -21013, /* B1 = -1.282532 */
9127 21577, /* B0 = 0.658508 */
9128 7, /* Internal filter scaling */
9129 159, /* Minimum in-band energy threshold */
9130 21, /* 21/32 in-band to broad-band ratio */
9131 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9132 },
9133 { /* f330_440[] 17 */
9134 30627, /* A1 = 1.869324 */
9135 -31338, /* A2 = -0.95636 */
9136 -843, /* B2 = -0.025749 */
9137 0, /* B1 = 0 */
9138 843, /* B0 = 0.025749 */
9139 30550, /* A1 = 1.864685 */
9140 -32221, /* A2 = -0.983337 */
9141 13594, /* B2 = 0.414886 */
9142 -12589, /* B1 = -0.768402 */
9143 13594, /* B0 = 0.414886 */
9144 31488, /* A1 = 1.921936 */
9145 -32358, /* A2 = -0.987518 */
9146 24684, /* B2 = 0.753296 */
9147 -24029, /* B1 = -1.466614 */
9148 24684, /* B0 = 0.753296 */
9149 7, /* Internal filter scaling */
9150 159, /* Minimum in-band energy threshold */
9151 21, /* 21/32 in-band to broad-band ratio */
9152 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9153 },
9154 { /* f340 18 */
9155 31546, /* A1 = -1.925476 */
9156 -32646, /* A2 = 0.996277 */
9157 -445, /* B2 = -0.013588 */
9158 0, /* B1 = 0.000000 */
9159 445, /* B0 = 0.013588 */
9160 31551, /* A1 = -1.925781 */
9161 -32713, /* A2 = 0.998352 */
9162 23884, /* B2 = 0.728882 */
9163 -22979, /* B1 = -1.402527 */
9164 23884, /* B0 = 0.728882 */
9165 31606, /* A1 = -1.929138 */
9166 -32715, /* A2 = 0.998413 */
9167 863, /* B2 = 0.026367 */
9168 -835, /* B1 = -0.050985 */
9169 863, /* B0 = 0.026367 */
9170 5, /* Internal filter scaling */
9171 159, /* Minimum in-band energy threshold */
9172 21, /* 21/32 in-band to broad-band ratio */
9173 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9174 },
9175 { /* f350_400[] 19 */
9176 31006, /* A1 = 1.892517 */
9177 -32029, /* A2 = -0.977448 */
9178 -461, /* B2 = -0.014096 */
9179 0, /* B1 = 0 */
9180 461, /* B0 = 0.014096 */
9181 30999, /* A1 = 1.892029 */
9182 -32487, /* A2 = -0.991455 */
9183 11325, /* B2 = 0.345612 */
9184 -10682, /* B1 = -0.651978 */
9185 11325, /* B0 = 0.345612 */
9186 31441, /* A1 = 1.919067 */
9187 -32526, /* A2 = -0.992615 */
9188 24324, /* B2 = 0.74231 */
9189 -23535, /* B1 = -1.436523 */
9190 24324, /* B0 = 0.74231 */
9191 7, /* Internal filter scaling */
9192 159, /* Minimum in-band energy threshold */
9193 21, /* 21/32 in-band to broad-band ratio */
9194 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9195 },
9196 { /* f350_440[] */
9197 30634, /* A1 = 1.869751 */
9198 -31533, /* A2 = -0.962341 */
9199 -680, /* B2 = -0.020782 */
9200 0, /* B1 = 0 */
9201 680, /* B0 = 0.020782 */
9202 30571, /* A1 = 1.865906 */
9203 -32277, /* A2 = -0.985016 */
9204 12894, /* B2 = 0.393524 */
9205 -11945, /* B1 = -0.729065 */
9206 12894, /* B0 = 0.393524 */
9207 31367, /* A1 = 1.91449 */
9208 -32379, /* A2 = -0.988129 */
9209 23820, /* B2 = 0.726929 */
9210 -23104, /* B1 = -1.410217 */
9211 23820, /* B0 = 0.726929 */
9212 7, /* Internal filter scaling */
9213 159, /* Minimum in-band energy threshold */
9214 21, /* 21/32 in-band to broad-band ratio */
9215 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9216 },
9217 { /* f350_450[] */
9218 30552, /* A1 = 1.864807 */
9219 -31434, /* A2 = -0.95929 */
9220 -690, /* B2 = -0.021066 */
9221 0, /* B1 = 0 */
9222 690, /* B0 = 0.021066 */
9223 30472, /* A1 = 1.859924 */
9224 -32248, /* A2 = -0.984161 */
9225 13385, /* B2 = 0.408478 */
9226 -12357, /* B1 = -0.754242 */
9227 13385, /* B0 = 0.408478 */
9228 31358, /* A1 = 1.914001 */
9229 -32366, /* A2 = -0.987732 */
9230 26488, /* B2 = 0.80835 */
9231 -25692, /* B1 = -1.568176 */
9232 26490, /* B0 = 0.808411 */
9233 7, /* Internal filter scaling */
9234 159, /* Minimum in-band energy threshold */
9235 21, /* 21/32 in-band to broad-band ratio */
9236 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9237 },
9238 { /* f360 */
9239 31397, /* A1 = -1.916321 */
9240 -32623, /* A2 = 0.995605 */
9241 -117, /* B2 = -0.003598 */
9242 0, /* B1 = 0.000000 */
9243 117, /* B0 = 0.003598 */
9244 31403, /* A1 = -1.916687 */
9245 -32700, /* A2 = 0.997925 */
9246 3388, /* B2 = 0.103401 */
9247 -3240, /* B1 = -0.197784 */
9248 3388, /* B0 = 0.103401 */
9249 31463, /* A1 = -1.920410 */
9250 -32702, /* A2 = 0.997986 */
9251 13346, /* B2 = 0.407288 */
9252 -12863, /* B1 = -0.785126 */
9253 13346, /* B0 = 0.407288 */
9254 5, /* Internal filter scaling */
9255 159, /* Minimum in-band energy threshold */
9256 21, /* 21/32 in-band to broad-band ratio */
9257 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9258 },
9259 { /* f380_420[] */
9260 30831, /* A1 = 1.881775 */
9261 -32064, /* A2 = -0.978546 */
9262 -367, /* B2 = -0.01122 */
9263 0, /* B1 = 0 */
9264 367, /* B0 = 0.01122 */
9265 30813, /* A1 = 1.880737 */
9266 -32456, /* A2 = -0.990509 */
9267 11068, /* B2 = 0.337769 */
9268 -10338, /* B1 = -0.631042 */
9269 11068, /* B0 = 0.337769 */
9270 31214, /* A1 = 1.905212 */
9271 -32491, /* A2 = -0.991577 */
9272 16374, /* B2 = 0.499695 */
9273 -15781, /* B1 = -0.963196 */
9274 16374, /* B0 = 0.499695 */
9275 7, /* Internal filter scaling */
9276 159, /* Minimum in-band energy threshold */
9277 21, /* 21/32 in-band to broad-band ratio */
9278 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9279 },
9280 { /* f392 */
9281 31152, /* A1 = -1.901428 */
9282 -32613, /* A2 = 0.995300 */
9283 -314, /* B2 = -0.009605 */
9284 0, /* B1 = 0.000000 */
9285 314, /* B0 = 0.009605 */
9286 31156, /* A1 = -1.901672 */
9287 -32694, /* A2 = 0.997742 */
9288 28847, /* B2 = 0.880371 */
9289 -2734, /* B1 = -0.166901 */
9290 28847, /* B0 = 0.880371 */
9291 31225, /* A1 = -1.905823 */
9292 -32696, /* A2 = 0.997803 */
9293 462, /* B2 = 0.014108 */
9294 -442, /* B1 = -0.027019 */
9295 462, /* B0 = 0.014108 */
9296 5, /* Internal filter scaling */
9297 159, /* Minimum in-band energy threshold */
9298 21, /* 21/32 in-band to broad-band ratio */
9299 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9300 },
9301 { /* f400_425[] */
9302 30836, /* A1 = 1.882141 */
9303 -32296, /* A2 = -0.985596 */
9304 -324, /* B2 = -0.009903 */
9305 0, /* B1 = 0 */
9306 324, /* B0 = 0.009903 */
9307 30825, /* A1 = 1.881409 */
9308 -32570, /* A2 = -0.993958 */
9309 16847, /* B2 = 0.51416 */
9310 -15792, /* B1 = -0.963898 */
9311 16847, /* B0 = 0.51416 */
9312 31106, /* A1 = 1.89856 */
9313 -32584, /* A2 = -0.994415 */
9314 9579, /* B2 = 0.292328 */
9315 -9164, /* B1 = -0.559357 */
9316 9579, /* B0 = 0.292328 */
9317 7, /* Internal filter scaling */
9318 159, /* Minimum in-band energy threshold */
9319 21, /* 21/32 in-band to broad-band ratio */
9320 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9321 },
9322 { /* f400_440[] */
9323 30702, /* A1 = 1.873962 */
9324 -32134, /* A2 = -0.980682 */
9325 -517, /* B2 = -0.015793 */
9326 0, /* B1 = 0 */
9327 517, /* B0 = 0.015793 */
9328 30676, /* A1 = 1.872375 */
9329 -32520, /* A2 = -0.992462 */
9330 8144, /* B2 = 0.24855 */
9331 -7596, /* B1 = -0.463684 */
9332 8144, /* B0 = 0.24855 */
9333 31084, /* A1 = 1.897217 */
9334 -32547, /* A2 = -0.993256 */
9335 22713, /* B2 = 0.693176 */
9336 -21734, /* B1 = -1.326599 */
9337 22713, /* B0 = 0.693176 */
9338 7, /* Internal filter scaling */
9339 159, /* Minimum in-band energy threshold */
9340 21, /* 21/32 in-band to broad-band ratio */
9341 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9342 },
9343 { /* f400_450[] */
9344 30613, /* A1 = 1.86853 */
9345 -32031, /* A2 = -0.977509 */
9346 -618, /* B2 = -0.018866 */
9347 0, /* B1 = 0 */
9348 618, /* B0 = 0.018866 */
9349 30577, /* A1 = 1.866272 */
9350 -32491, /* A2 = -0.991577 */
9351 9612, /* B2 = 0.293335 */
9352 -8935, /* B1 = -0.54541 */
9353 9612, /* B0 = 0.293335 */
9354 31071, /* A1 = 1.896484 */
9355 -32524, /* A2 = -0.992584 */
9356 21596, /* B2 = 0.659058 */
9357 -20667, /* B1 = -1.261414 */
9358 21596, /* B0 = 0.659058 */
9359 7, /* Internal filter scaling */
9360 159, /* Minimum in-band energy threshold */
9361 21, /* 21/32 in-band to broad-band ratio */
9362 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9363 },
9364 { /* f420 */
9365 30914, /* A1 = -1.886841 */
9366 -32584, /* A2 = 0.994385 */
9367 -426, /* B2 = -0.013020 */
9368 0, /* B1 = 0.000000 */
9369 426, /* B0 = 0.013020 */
9370 30914, /* A1 = -1.886841 */
9371 -32679, /* A2 = 0.997314 */
9372 17520, /* B2 = 0.534668 */
9373 -16471, /* B1 = -1.005310 */
9374 17520, /* B0 = 0.534668 */
9375 31004, /* A1 = -1.892334 */
9376 -32683, /* A2 = 0.997406 */
9377 819, /* B2 = 0.025023 */
9378 -780, /* B1 = -0.047619 */
9379 819, /* B0 = 0.025023 */
9380 5, /* Internal filter scaling */
9381 159, /* Minimum in-band energy threshold */
9382 21, /* 21/32 in-band to broad-band ratio */
9383 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9384 },
9385 #if 0
9386 { /* f425 */
9387 30881, /* A1 = -1.884827 */
9388 -32603, /* A2 = 0.994965 */
9389 -496, /* B2 = -0.015144 */
9390 0, /* B1 = 0.000000 */
9391 496, /* B0 = 0.015144 */
9392 30880, /* A1 = -1.884766 */
9393 -32692, /* A2 = 0.997711 */
9394 24767, /* B2 = 0.755859 */
9395 -23290, /* B1 = -1.421509 */
9396 24767, /* B0 = 0.755859 */
9397 30967, /* A1 = -1.890076 */
9398 -32694, /* A2 = 0.997772 */
9399 728, /* B2 = 0.022232 */
9400 -691, /* B1 = -0.042194 */
9401 728, /* B0 = 0.022232 */
9402 5, /* Internal filter scaling */
9403 159, /* Minimum in-band energy threshold */
9404 21, /* 21/32 in-band to broad-band ratio */
9405 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9406 },
9407 #else
9408 {
9409 30850,
9410 -32534,
9411 -504,
9412 0,
9413 504,
9414 30831,
9415 -32669,
9416 24303,
9417 -22080,
9418 24303,
9419 30994,
9420 -32673,
9421 1905,
9422 -1811,
9423 1905,
9424 5,
9425 129,
9426 17,
9427 0xff5
9428 },
9429 #endif
9430 { /* f425_450[] */
9431 30646, /* A1 = 1.870544 */
9432 -32327, /* A2 = -0.986572 */
9433 -287, /* B2 = -0.008769 */
9434 0, /* B1 = 0 */
9435 287, /* B0 = 0.008769 */
9436 30627, /* A1 = 1.869324 */
9437 -32607, /* A2 = -0.995087 */
9438 13269, /* B2 = 0.404968 */
9439 -12376, /* B1 = -0.755432 */
9440 13269, /* B0 = 0.404968 */
9441 30924, /* A1 = 1.887512 */
9442 -32619, /* A2 = -0.995453 */
9443 19950, /* B2 = 0.608826 */
9444 -18940, /* B1 = -1.156006 */
9445 19950, /* B0 = 0.608826 */
9446 7, /* Internal filter scaling */
9447 159, /* Minimum in-band energy threshold */
9448 21, /* 21/32 in-band to broad-band ratio */
9449 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9450 },
9451 { /* f425_475[] */
9452 30396, /* A1 = 1.855225 */
9453 -32014, /* A2 = -0.97699 */
9454 -395, /* B2 = -0.012055 */
9455 0, /* B1 = 0 */
9456 395, /* B0 = 0.012055 */
9457 30343, /* A1 = 1.85199 */
9458 -32482, /* A2 = -0.991302 */
9459 17823, /* B2 = 0.543945 */
9460 -16431, /* B1 = -1.002869 */
9461 17823, /* B0 = 0.543945 */
9462 30872, /* A1 = 1.884338 */
9463 -32516, /* A2 = -0.99231 */
9464 18124, /* B2 = 0.553101 */
9465 -17246, /* B1 = -1.052673 */
9466 18124, /* B0 = 0.553101 */
9467 7, /* Internal filter scaling */
9468 159, /* Minimum in-band energy threshold */
9469 21, /* 21/32 in-band to broad-band ratio */
9470 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9471 },
9472 { /* f435 */
9473 30796, /* A1 = -1.879639 */
9474 -32603, /* A2 = 0.994965 */
9475 -254, /* B2 = -0.007762 */
9476 0, /* B1 = 0.000000 */
9477 254, /* B0 = 0.007762 */
9478 30793, /* A1 = -1.879456 */
9479 -32692, /* A2 = 0.997711 */
9480 18934, /* B2 = 0.577820 */
9481 -17751, /* B1 = -1.083496 */
9482 18934, /* B0 = 0.577820 */
9483 30882, /* A1 = -1.884888 */
9484 -32694, /* A2 = 0.997772 */
9485 1858, /* B2 = 0.056713 */
9486 -1758, /* B1 = -0.107357 */
9487 1858, /* B0 = 0.056713 */
9488 5, /* Internal filter scaling */
9489 159, /* Minimum in-band energy threshold */
9490 21, /* 21/32 in-band to broad-band ratio */
9491 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9492 },
9493 { /* f440_450[] */
9494 30641, /* A1 = 1.870239 */
9495 -32458, /* A2 = -0.99057 */
9496 -155, /* B2 = -0.004735 */
9497 0, /* B1 = 0 */
9498 155, /* B0 = 0.004735 */
9499 30631, /* A1 = 1.869568 */
9500 -32630, /* A2 = -0.995789 */
9501 11453, /* B2 = 0.349548 */
9502 -10666, /* B1 = -0.651001 */
9503 11453, /* B0 = 0.349548 */
9504 30810, /* A1 = 1.880554 */
9505 -32634, /* A2 = -0.995941 */
9506 12237, /* B2 = 0.373474 */
9507 -11588, /* B1 = -0.707336 */
9508 12237, /* B0 = 0.373474 */
9509 7, /* Internal filter scaling */
9510 159, /* Minimum in-band energy threshold */
9511 21, /* 21/32 in-band to broad-band ratio */
9512 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9513 },
9514 { /* f440_480[] */
9515 30367, /* A1 = 1.853455 */
9516 -32147, /* A2 = -0.981079 */
9517 -495, /* B2 = -0.015113 */
9518 0, /* B1 = 0 */
9519 495, /* B0 = 0.015113 */
9520 30322, /* A1 = 1.850769 */
9521 -32543, /* A2 = -0.993134 */
9522 10031, /* B2 = 0.306152 */
9523 -9252, /* B1 = -0.564728 */
9524 10031, /* B0 = 0.306152 */
9525 30770, /* A1 = 1.878052 */
9526 -32563, /* A2 = -0.993774 */
9527 22674, /* B2 = 0.691956 */
9528 -21465, /* B1 = -1.31012 */
9529 22674, /* B0 = 0.691956 */
9530 7, /* Internal filter scaling */
9531 159, /* Minimum in-band energy threshold */
9532 21, /* 21/32 in-band to broad-band ratio */
9533 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9534 },
9535 { /* f445 */
9536 30709, /* A1 = -1.874329 */
9537 -32603, /* A2 = 0.994965 */
9538 -83, /* B2 = -0.002545 */
9539 0, /* B1 = 0.000000 */
9540 83, /* B0 = 0.002545 */
9541 30704, /* A1 = -1.874084 */
9542 -32692, /* A2 = 0.997711 */
9543 10641, /* B2 = 0.324738 */
9544 -9947, /* B1 = -0.607147 */
9545 10641, /* B0 = 0.324738 */
9546 30796, /* A1 = -1.879639 */
9547 -32694, /* A2 = 0.997772 */
9548 10079, /* B2 = 0.307587 */
9549 9513, /* B1 = 0.580688 */
9550 10079, /* B0 = 0.307587 */
9551 5, /* Internal filter scaling */
9552 159, /* Minimum in-band energy threshold */
9553 21, /* 21/32 in-band to broad-band ratio */
9554 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9555 },
9556 { /* f450 */
9557 30664, /* A1 = -1.871643 */
9558 -32603, /* A2 = 0.994965 */
9559 -164, /* B2 = -0.005029 */
9560 0, /* B1 = 0.000000 */
9561 164, /* B0 = 0.005029 */
9562 30661, /* A1 = -1.871399 */
9563 -32692, /* A2 = 0.997711 */
9564 15294, /* B2 = 0.466736 */
9565 -14275, /* B1 = -0.871307 */
9566 15294, /* B0 = 0.466736 */
9567 30751, /* A1 = -1.876953 */
9568 -32694, /* A2 = 0.997772 */
9569 3548, /* B2 = 0.108284 */
9570 -3344, /* B1 = -0.204155 */
9571 3548, /* B0 = 0.108284 */
9572 5, /* Internal filter scaling */
9573 159, /* Minimum in-band energy threshold */
9574 21, /* 21/32 in-band to broad-band ratio */
9575 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9576 },
9577 { /* f452 */
9578 30653, /* A1 = -1.870911 */
9579 -32615, /* A2 = 0.995361 */
9580 -209, /* B2 = -0.006382 */
9581 0, /* B1 = 0.000000 */
9582 209, /* B0 = 0.006382 */
9583 30647, /* A1 = -1.870605 */
9584 -32702, /* A2 = 0.997986 */
9585 18971, /* B2 = 0.578979 */
9586 -17716, /* B1 = -1.081299 */
9587 18971, /* B0 = 0.578979 */
9588 30738, /* A1 = -1.876099 */
9589 -32702, /* A2 = 0.998016 */
9590 2967, /* B2 = 0.090561 */
9591 -2793, /* B1 = -0.170502 */
9592 2967, /* B0 = 0.090561 */
9593 5, /* Internal filter scaling */
9594 159, /* Minimum in-band energy threshold */
9595 21, /* 21/32 in-band to broad-band ratio */
9596 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9597 },
9598 { /* f475 */
9599 30437, /* A1 = -1.857727 */
9600 -32603, /* A2 = 0.994965 */
9601 -264, /* B2 = -0.008062 */
9602 0, /* B1 = 0.000000 */
9603 264, /* B0 = 0.008062 */
9604 30430, /* A1 = -1.857300 */
9605 -32692, /* A2 = 0.997711 */
9606 21681, /* B2 = 0.661682 */
9607 -20082, /* B1 = -1.225708 */
9608 21681, /* B0 = 0.661682 */
9609 30526, /* A1 = -1.863220 */
9610 -32694, /* A2 = 0.997742 */
9611 1559, /* B2 = 0.047600 */
9612 -1459, /* B1 = -0.089096 */
9613 1559, /* B0 = 0.047600 */
9614 5, /* Internal filter scaling */
9615 159, /* Minimum in-band energy threshold */
9616 21, /* 21/32 in-band to broad-band ratio */
9617 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9618 },
9619 { /* f480_620[] */
9620 28975, /* A1 = 1.768494 */
9621 -30955, /* A2 = -0.944672 */
9622 -1026, /* B2 = -0.03133 */
9623 0, /* B1 = 0 */
9624 1026, /* B0 = 0.03133 */
9625 28613, /* A1 = 1.746399 */
9626 -32089, /* A2 = -0.979309 */
9627 14214, /* B2 = 0.433807 */
9628 -12202, /* B1 = -0.744812 */
9629 14214, /* B0 = 0.433807 */
9630 30243, /* A1 = 1.845947 */
9631 -32238, /* A2 = -0.983856 */
9632 24825, /* B2 = 0.757629 */
9633 -23402, /* B1 = -1.428345 */
9634 24825, /* B0 = 0.757629 */
9635 7, /* Internal filter scaling */
9636 159, /* Minimum in-band energy threshold */
9637 21, /* 21/32 in-band to broad-band ratio */
9638 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9639 },
9640 { /* f494 */
9641 30257, /* A1 = -1.846741 */
9642 -32605, /* A2 = 0.995056 */
9643 -249, /* B2 = -0.007625 */
9644 0, /* B1 = 0.000000 */
9645 249, /* B0 = 0.007625 */
9646 30247, /* A1 = -1.846191 */
9647 -32694, /* A2 = 0.997772 */
9648 18088, /* B2 = 0.552002 */
9649 -16652, /* B1 = -1.016418 */
9650 18088, /* B0 = 0.552002 */
9651 30348, /* A1 = -1.852295 */
9652 -32696, /* A2 = 0.997803 */
9653 2099, /* B2 = 0.064064 */
9654 -1953, /* B1 = -0.119202 */
9655 2099, /* B0 = 0.064064 */
9656 5, /* Internal filter scaling */
9657 159, /* Minimum in-band energy threshold */
9658 21, /* 21/32 in-band to broad-band ratio */
9659 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9660 },
9661 { /* f500 */
9662 30202, /* A1 = -1.843431 */
9663 -32624, /* A2 = 0.995622 */
9664 -413, /* B2 = -0.012622 */
9665 0, /* B1 = 0.000000 */
9666 413, /* B0 = 0.012622 */
9667 30191, /* A1 = -1.842721 */
9668 -32714, /* A2 = 0.998364 */
9669 25954, /* B2 = 0.792057 */
9670 -23890, /* B1 = -1.458131 */
9671 25954, /* B0 = 0.792057 */
9672 30296, /* A1 = -1.849172 */
9673 -32715, /* A2 = 0.998397 */
9674 2007, /* B2 = 0.061264 */
9675 -1860, /* B1 = -0.113568 */
9676 2007, /* B0 = 0.061264 */
9677 5, /* Internal filter scaling */
9678 159, /* Minimum in-band energy threshold */
9679 21, /* 21/32 in-band to broad-band ratio */
9680 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9681 },
9682 { /* f520 */
9683 30001, /* A1 = -1.831116 */
9684 -32613, /* A2 = 0.995270 */
9685 -155, /* B2 = -0.004750 */
9686 0, /* B1 = 0.000000 */
9687 155, /* B0 = 0.004750 */
9688 29985, /* A1 = -1.830200 */
9689 -32710, /* A2 = 0.998260 */
9690 6584, /* B2 = 0.200928 */
9691 -6018, /* B1 = -0.367355 */
9692 6584, /* B0 = 0.200928 */
9693 30105, /* A1 = -1.837524 */
9694 -32712, /* A2 = 0.998291 */
9695 23812, /* B2 = 0.726685 */
9696 -21936, /* B1 = -1.338928 */
9697 23812, /* B0 = 0.726685 */
9698 5, /* Internal filter scaling */
9699 159, /* Minimum in-band energy threshold */
9700 21, /* 21/32 in-band to broad-band ratio */
9701 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9702 },
9703 { /* f523 */
9704 29964, /* A1 = -1.828918 */
9705 -32601, /* A2 = 0.994904 */
9706 -101, /* B2 = -0.003110 */
9707 0, /* B1 = 0.000000 */
9708 101, /* B0 = 0.003110 */
9709 29949, /* A1 = -1.827942 */
9710 -32700, /* A2 = 0.997925 */
9711 11041, /* B2 = 0.336975 */
9712 -10075, /* B1 = -0.614960 */
9713 11041, /* B0 = 0.336975 */
9714 30070, /* A1 = -1.835388 */
9715 -32702, /* A2 = 0.997986 */
9716 16762, /* B2 = 0.511536 */
9717 -15437, /* B1 = -0.942230 */
9718 16762, /* B0 = 0.511536 */
9719 5, /* Internal filter scaling */
9720 159, /* Minimum in-band energy threshold */
9721 21, /* 21/32 in-band to broad-band ratio */
9722 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9723 },
9724 { /* f525 */
9725 29936, /* A1 = -1.827209 */
9726 -32584, /* A2 = 0.994415 */
9727 -91, /* B2 = -0.002806 */
9728 0, /* B1 = 0.000000 */
9729 91, /* B0 = 0.002806 */
9730 29921, /* A1 = -1.826233 */
9731 -32688, /* A2 = 0.997559 */
9732 11449, /* B2 = 0.349396 */
9733 -10426, /* B1 = -0.636383 */
9734 11449, /* B0 = 0.349396 */
9735 30045, /* A1 = -1.833862 */
9736 -32688, /* A2 = 0.997589 */
9737 13055, /* B2 = 0.398407 */
9738 -12028, /* B1 = -0.734161 */
9739 13055, /* B0 = 0.398407 */
9740 5, /* Internal filter scaling */
9741 159, /* Minimum in-band energy threshold */
9742 21, /* 21/32 in-band to broad-band ratio */
9743 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9744 },
9745 { /* f540_660[] */
9746 28499, /* A1 = 1.739441 */
9747 -31129, /* A2 = -0.949982 */
9748 -849, /* B2 = -0.025922 */
9749 0, /* B1 = 0 */
9750 849, /* B0 = 0.025922 */
9751 28128, /* A1 = 1.716797 */
9752 -32130, /* A2 = -0.98056 */
9753 14556, /* B2 = 0.444214 */
9754 -12251, /* B1 = -0.747772 */
9755 14556, /* B0 = 0.444244 */
9756 29667, /* A1 = 1.81073 */
9757 -32244, /* A2 = -0.984039 */
9758 23038, /* B2 = 0.703064 */
9759 -21358, /* B1 = -1.303589 */
9760 23040, /* B0 = 0.703125 */
9761 7, /* Internal filter scaling */
9762 159, /* Minimum in-band energy threshold */
9763 21, /* 21/32 in-band to broad-band ratio */
9764 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9765 },
9766 { /* f587 */
9767 29271, /* A1 = -1.786560 */
9768 -32599, /* A2 = 0.994873 */
9769 -490, /* B2 = -0.014957 */
9770 0, /* B1 = 0.000000 */
9771 490, /* B0 = 0.014957 */
9772 29246, /* A1 = -1.785095 */
9773 -32700, /* A2 = 0.997925 */
9774 28961, /* B2 = 0.883850 */
9775 -25796, /* B1 = -1.574463 */
9776 28961, /* B0 = 0.883850 */
9777 29383, /* A1 = -1.793396 */
9778 -32700, /* A2 = 0.997955 */
9779 1299, /* B2 = 0.039650 */
9780 -1169, /* B1 = -0.071396 */
9781 1299, /* B0 = 0.039650 */
9782 5, /* Internal filter scaling */
9783 159, /* Minimum in-band energy threshold */
9784 21, /* 21/32 in-band to broad-band ratio */
9785 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9786 },
9787 { /* f590 */
9788 29230, /* A1 = -1.784058 */
9789 -32584, /* A2 = 0.994415 */
9790 -418, /* B2 = -0.012757 */
9791 0, /* B1 = 0.000000 */
9792 418, /* B0 = 0.012757 */
9793 29206, /* A1 = -1.782593 */
9794 -32688, /* A2 = 0.997559 */
9795 36556, /* B2 = 1.115601 */
9796 -32478, /* B1 = -1.982300 */
9797 36556, /* B0 = 1.115601 */
9798 29345, /* A1 = -1.791077 */
9799 -32688, /* A2 = 0.997589 */
9800 897, /* B2 = 0.027397 */
9801 -808, /* B1 = -0.049334 */
9802 897, /* B0 = 0.027397 */
9803 5, /* Internal filter scaling */
9804 159, /* Minimum in-band energy threshold */
9805 21, /* 21/32 in-band to broad-band ratio */
9806 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9807 },
9808 { /* f600 */
9809 29116, /* A1 = -1.777100 */
9810 -32603, /* A2 = 0.994965 */
9811 -165, /* B2 = -0.005039 */
9812 0, /* B1 = 0.000000 */
9813 165, /* B0 = 0.005039 */
9814 29089, /* A1 = -1.775452 */
9815 -32708, /* A2 = 0.998199 */
9816 6963, /* B2 = 0.212494 */
9817 -6172, /* B1 = -0.376770 */
9818 6963, /* B0 = 0.212494 */
9819 29237, /* A1 = -1.784485 */
9820 -32710, /* A2 = 0.998230 */
9821 24197, /* B2 = 0.738464 */
9822 -21657, /* B1 = -1.321899 */
9823 24197, /* B0 = 0.738464 */
9824 5, /* Internal filter scaling */
9825 159, /* Minimum in-band energy threshold */
9826 21, /* 21/32 in-band to broad-band ratio */
9827 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9828 },
9829 { /* f660 */
9830 28376, /* A1 = -1.731934 */
9831 -32567, /* A2 = 0.993896 */
9832 -363, /* B2 = -0.011102 */
9833 0, /* B1 = 0.000000 */
9834 363, /* B0 = 0.011102 */
9835 28337, /* A1 = -1.729614 */
9836 -32683, /* A2 = 0.997434 */
9837 21766, /* B2 = 0.664246 */
9838 -18761, /* B1 = -1.145081 */
9839 21766, /* B0 = 0.664246 */
9840 28513, /* A1 = -1.740356 */
9841 -32686, /* A2 = 0.997498 */
9842 2509, /* B2 = 0.076584 */
9843 -2196, /* B1 = -0.134041 */
9844 2509, /* B0 = 0.076584 */
9845 5, /* Internal filter scaling */
9846 159, /* Minimum in-band energy threshold */
9847 21, /* 21/32 in-band to broad-band ratio */
9848 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9849 },
9850 { /* f700 */
9851 27844, /* A1 = -1.699463 */
9852 -32563, /* A2 = 0.993744 */
9853 -366, /* B2 = -0.011187 */
9854 0, /* B1 = 0.000000 */
9855 366, /* B0 = 0.011187 */
9856 27797, /* A1 = -1.696655 */
9857 -32686, /* A2 = 0.997498 */
9858 22748, /* B2 = 0.694214 */
9859 -19235, /* B1 = -1.174072 */
9860 22748, /* B0 = 0.694214 */
9861 27995, /* A1 = -1.708740 */
9862 -32688, /* A2 = 0.997559 */
9863 2964, /* B2 = 0.090477 */
9864 -2546, /* B1 = -0.155449 */
9865 2964, /* B0 = 0.090477 */
9866 5, /* Internal filter scaling */
9867 159, /* Minimum in-band energy threshold */
9868 21, /* 21/32 in-band to broad-band ratio */
9869 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9870 },
9871 { /* f740 */
9872 27297, /* A1 = -1.666077 */
9873 -32551, /* A2 = 0.993408 */
9874 -345, /* B2 = -0.010540 */
9875 0, /* B1 = 0.000000 */
9876 345, /* B0 = 0.010540 */
9877 27240, /* A1 = -1.662598 */
9878 -32683, /* A2 = 0.997406 */
9879 22560, /* B2 = 0.688477 */
9880 -18688, /* B1 = -1.140625 */
9881 22560, /* B0 = 0.688477 */
9882 27461, /* A1 = -1.676147 */
9883 -32684, /* A2 = 0.997467 */
9884 3541, /* B2 = 0.108086 */
9885 -2985, /* B1 = -0.182220 */
9886 3541, /* B0 = 0.108086 */
9887 5, /* Internal filter scaling */
9888 159, /* Minimum in-band energy threshold */
9889 21, /* 21/32 in-band to broad-band ratio */
9890 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9891 },
9892 { /* f750 */
9893 27155, /* A1 = -1.657410 */
9894 -32551, /* A2 = 0.993408 */
9895 -462, /* B2 = -0.014117 */
9896 0, /* B1 = 0.000000 */
9897 462, /* B0 = 0.014117 */
9898 27097, /* A1 = -1.653870 */
9899 -32683, /* A2 = 0.997406 */
9900 32495, /* B2 = 0.991699 */
9901 -26776, /* B1 = -1.634338 */
9902 32495, /* B0 = 0.991699 */
9903 27321, /* A1 = -1.667542 */
9904 -32684, /* A2 = 0.997467 */
9905 1835, /* B2 = 0.056007 */
9906 -1539, /* B1 = -0.093948 */
9907 1835, /* B0 = 0.056007 */
9908 5, /* Internal filter scaling */
9909 159, /* Minimum in-band energy threshold */
9910 21, /* 21/32 in-band to broad-band ratio */
9911 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9912 },
9913 { /* f750_1450[] */
9914 19298, /* A1 = 1.177917 */
9915 -24471, /* A2 = -0.746796 */
9916 -4152, /* B2 = -0.126709 */
9917 0, /* B1 = 0 */
9918 4152, /* B0 = 0.126709 */
9919 12902, /* A1 = 0.787476 */
9920 -29091, /* A2 = -0.887817 */
9921 12491, /* B2 = 0.38121 */
9922 -1794, /* B1 = -0.109528 */
9923 12494, /* B0 = 0.381317 */
9924 26291, /* A1 = 1.604736 */
9925 -30470, /* A2 = -0.929901 */
9926 28859, /* B2 = 0.880737 */
9927 -26084, /* B1 = -1.592102 */
9928 28861, /* B0 = 0.880798 */
9929 7, /* Internal filter scaling */
9930 159, /* Minimum in-band energy threshold */
9931 21, /* 21/32 in-band to broad-band ratio */
9932 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9933 },
9934 { /* f770 */
9935 26867, /* A1 = -1.639832 */
9936 -32551, /* A2 = 0.993408 */
9937 -123, /* B2 = -0.003755 */
9938 0, /* B1 = 0.000000 */
9939 123, /* B0 = 0.003755 */
9940 26805, /* A1 = -1.636108 */
9941 -32683, /* A2 = 0.997406 */
9942 17297, /* B2 = 0.527863 */
9943 -14096, /* B1 = -0.860382 */
9944 17297, /* B0 = 0.527863 */
9945 27034, /* A1 = -1.650085 */
9946 -32684, /* A2 = 0.997467 */
9947 12958, /* B2 = 0.395477 */
9948 -10756, /* B1 = -0.656525 */
9949 12958, /* B0 = 0.395477 */
9950 5, /* Internal filter scaling */
9951 159, /* Minimum in-band energy threshold */
9952 21, /* 21/32 in-band to broad-band ratio */
9953 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9954 },
9955 { /* f800 */
9956 26413, /* A1 = -1.612122 */
9957 -32547, /* A2 = 0.993286 */
9958 -223, /* B2 = -0.006825 */
9959 0, /* B1 = 0.000000 */
9960 223, /* B0 = 0.006825 */
9961 26342, /* A1 = -1.607849 */
9962 -32686, /* A2 = 0.997498 */
9963 6391, /* B2 = 0.195053 */
9964 -5120, /* B1 = -0.312531 */
9965 6391, /* B0 = 0.195053 */
9966 26593, /* A1 = -1.623108 */
9967 -32688, /* A2 = 0.997559 */
9968 23681, /* B2 = 0.722717 */
9969 -19328, /* B1 = -1.179688 */
9970 23681, /* B0 = 0.722717 */
9971 5, /* Internal filter scaling */
9972 159, /* Minimum in-band energy threshold */
9973 21, /* 21/32 in-band to broad-band ratio */
9974 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9975 },
9976 { /* f816 */
9977 26168, /* A1 = -1.597209 */
9978 -32528, /* A2 = 0.992706 */
9979 -235, /* B2 = -0.007182 */
9980 0, /* B1 = 0.000000 */
9981 235, /* B0 = 0.007182 */
9982 26092, /* A1 = -1.592590 */
9983 -32675, /* A2 = 0.997192 */
9984 20823, /* B2 = 0.635498 */
9985 -16510, /* B1 = -1.007751 */
9986 20823, /* B0 = 0.635498 */
9987 26363, /* A1 = -1.609070 */
9988 -32677, /* A2 = 0.997253 */
9989 6739, /* B2 = 0.205688 */
9990 -5459, /* B1 = -0.333206 */
9991 6739, /* B0 = 0.205688 */
9992 5, /* Internal filter scaling */
9993 159, /* Minimum in-band energy threshold */
9994 21, /* 21/32 in-band to broad-band ratio */
9995 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9996 },
9997 { /* f850 */
9998 25641, /* A1 = -1.565063 */
9999 -32536, /* A2 = 0.992950 */
10000 -121, /* B2 = -0.003707 */
10001 0, /* B1 = 0.000000 */
10002 121, /* B0 = 0.003707 */
10003 25560, /* A1 = -1.560059 */
10004 -32684, /* A2 = 0.997437 */
10005 18341, /* B2 = 0.559753 */
10006 -14252, /* B1 = -0.869904 */
10007 18341, /* B0 = 0.559753 */
10008 25837, /* A1 = -1.577026 */
10009 -32684, /* A2 = 0.997467 */
10010 16679, /* B2 = 0.509003 */
10011 -13232, /* B1 = -0.807648 */
10012 16679, /* B0 = 0.509003 */
10013 5, /* Internal filter scaling */
10014 159, /* Minimum in-band energy threshold */
10015 21, /* 21/32 in-band to broad-band ratio */
10016 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10017 },
10018 { /* f857_1645[] */
10019 16415, /* A1 = 1.001953 */
10020 -23669, /* A2 = -0.722321 */
10021 -4549, /* B2 = -0.138847 */
10022 0, /* B1 = 0 */
10023 4549, /* B0 = 0.138847 */
10024 8456, /* A1 = 0.516174 */
10025 -28996, /* A2 = -0.884918 */
10026 13753, /* B2 = 0.419724 */
10027 -12, /* B1 = -0.000763 */
10028 13757, /* B0 = 0.419846 */
10029 24632, /* A1 = 1.503418 */
10030 -30271, /* A2 = -0.923828 */
10031 29070, /* B2 = 0.887146 */
10032 -25265, /* B1 = -1.542114 */
10033 29073, /* B0 = 0.887268 */
10034 7, /* Internal filter scaling */
10035 159, /* Minimum in-band energy threshold */
10036 21, /* 21/32 in-band to broad-band ratio */
10037 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10038 },
10039 { /* f900 */
10040 24806, /* A1 = -1.514099 */
10041 -32501, /* A2 = 0.991852 */
10042 -326, /* B2 = -0.009969 */
10043 0, /* B1 = 0.000000 */
10044 326, /* B0 = 0.009969 */
10045 24709, /* A1 = -1.508118 */
10046 -32659, /* A2 = 0.996674 */
10047 20277, /* B2 = 0.618835 */
10048 -15182, /* B1 = -0.926636 */
10049 20277, /* B0 = 0.618835 */
10050 25022, /* A1 = -1.527222 */
10051 -32661, /* A2 = 0.996735 */
10052 4320, /* B2 = 0.131836 */
10053 -3331, /* B1 = -0.203339 */
10054 4320, /* B0 = 0.131836 */
10055 5, /* Internal filter scaling */
10056 159, /* Minimum in-band energy threshold */
10057 21, /* 21/32 in-band to broad-band ratio */
10058 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10059 },
10060 { /* f900_1300[] */
10061 19776, /* A1 = 1.207092 */
10062 -27437, /* A2 = -0.837341 */
10063 -2666, /* B2 = -0.081371 */
10064 0, /* B1 = 0 */
10065 2666, /* B0 = 0.081371 */
10066 16302, /* A1 = 0.995026 */
10067 -30354, /* A2 = -0.926361 */
10068 10389, /* B2 = 0.317062 */
10069 -3327, /* B1 = -0.203064 */
10070 10389, /* B0 = 0.317062 */
10071 24299, /* A1 = 1.483154 */
10072 -30930, /* A2 = -0.943909 */
10073 25016, /* B2 = 0.763428 */
10074 -21171, /* B1 = -1.292236 */
10075 25016, /* B0 = 0.763428 */
10076 7, /* Internal filter scaling */
10077 159, /* Minimum in-band energy threshold */
10078 21, /* 21/32 in-band to broad-band ratio */
10079 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10080 },
10081 { /* f935_1215[] */
10082 20554, /* A1 = 1.254517 */
10083 -28764, /* A2 = -0.877838 */
10084 -2048, /* B2 = -0.062515 */
10085 0, /* B1 = 0 */
10086 2048, /* B0 = 0.062515 */
10087 18209, /* A1 = 1.11145 */
10088 -30951, /* A2 = -0.94458 */
10089 9390, /* B2 = 0.286575 */
10090 -3955, /* B1 = -0.241455 */
10091 9390, /* B0 = 0.286575 */
10092 23902, /* A1 = 1.458923 */
10093 -31286, /* A2 = -0.954803 */
10094 23252, /* B2 = 0.709595 */
10095 -19132, /* B1 = -1.167725 */
10096 23252, /* B0 = 0.709595 */
10097 7, /* Internal filter scaling */
10098 159, /* Minimum in-band energy threshold */
10099 21, /* 21/32 in-band to broad-band ratio */
10100 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10101 },
10102 { /* f941_1477[] */
10103 17543, /* A1 = 1.07074 */
10104 -26220, /* A2 = -0.800201 */
10105 -3298, /* B2 = -0.100647 */
10106 0, /* B1 = 0 */
10107 3298, /* B0 = 0.100647 */
10108 12423, /* A1 = 0.75827 */
10109 -30036, /* A2 = -0.916626 */
10110 12651, /* B2 = 0.386078 */
10111 -2444, /* B1 = -0.14917 */
10112 12653, /* B0 = 0.386154 */
10113 23518, /* A1 = 1.435425 */
10114 -30745, /* A2 = -0.938293 */
10115 27282, /* B2 = 0.832581 */
10116 -22529, /* B1 = -1.375122 */
10117 27286, /* B0 = 0.832703 */
10118 7, /* Internal filter scaling */
10119 159, /* Minimum in-band energy threshold */
10120 21, /* 21/32 in-band to broad-band ratio */
10121 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10122 },
10123 { /* f942 */
10124 24104, /* A1 = -1.471252 */
10125 -32507, /* A2 = 0.992065 */
10126 -351, /* B2 = -0.010722 */
10127 0, /* B1 = 0.000000 */
10128 351, /* B0 = 0.010722 */
10129 23996, /* A1 = -1.464600 */
10130 -32671, /* A2 = 0.997040 */
10131 22848, /* B2 = 0.697266 */
10132 -16639, /* B1 = -1.015564 */
10133 22848, /* B0 = 0.697266 */
10134 24332, /* A1 = -1.485168 */
10135 -32673, /* A2 = 0.997101 */
10136 4906, /* B2 = 0.149727 */
10137 -3672, /* B1 = -0.224174 */
10138 4906, /* B0 = 0.149727 */
10139 5, /* Internal filter scaling */
10140 159, /* Minimum in-band energy threshold */
10141 21, /* 21/32 in-band to broad-band ratio */
10142 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10143 },
10144 { /* f950 */
10145 23967, /* A1 = -1.462830 */
10146 -32507, /* A2 = 0.992065 */
10147 -518, /* B2 = -0.015821 */
10148 0, /* B1 = 0.000000 */
10149 518, /* B0 = 0.015821 */
10150 23856, /* A1 = -1.456055 */
10151 -32671, /* A2 = 0.997040 */
10152 26287, /* B2 = 0.802246 */
10153 -19031, /* B1 = -1.161560 */
10154 26287, /* B0 = 0.802246 */
10155 24195, /* A1 = -1.476746 */
10156 -32673, /* A2 = 0.997101 */
10157 2890, /* B2 = 0.088196 */
10158 -2151, /* B1 = -0.131317 */
10159 2890, /* B0 = 0.088196 */
10160 5, /* Internal filter scaling */
10161 159, /* Minimum in-band energy threshold */
10162 21, /* 21/32 in-band to broad-band ratio */
10163 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10164 },
10165 { /* f950_1400[] */
10166 18294, /* A1 = 1.116638 */
10167 -26962, /* A2 = -0.822845 */
10168 -2914, /* B2 = -0.088936 */
10169 0, /* B1 = 0 */
10170 2914, /* B0 = 0.088936 */
10171 14119, /* A1 = 0.861786 */
10172 -30227, /* A2 = -0.922455 */
10173 11466, /* B2 = 0.349945 */
10174 -2833, /* B1 = -0.172943 */
10175 11466, /* B0 = 0.349945 */
10176 23431, /* A1 = 1.430115 */
10177 -30828, /* A2 = -0.940796 */
10178 25331, /* B2 = 0.773071 */
10179 -20911, /* B1 = -1.276367 */
10180 25331, /* B0 = 0.773071 */
10181 7, /* Internal filter scaling */
10182 159, /* Minimum in-band energy threshold */
10183 21, /* 21/32 in-band to broad-band ratio */
10184 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10185 },
10186 { /* f975 */
10187 23521, /* A1 = -1.435608 */
10188 -32489, /* A2 = 0.991516 */
10189 -193, /* B2 = -0.005915 */
10190 0, /* B1 = 0.000000 */
10191 193, /* B0 = 0.005915 */
10192 23404, /* A1 = -1.428467 */
10193 -32655, /* A2 = 0.996582 */
10194 17740, /* B2 = 0.541412 */
10195 -12567, /* B1 = -0.767029 */
10196 17740, /* B0 = 0.541412 */
10197 23753, /* A1 = -1.449829 */
10198 -32657, /* A2 = 0.996613 */
10199 9090, /* B2 = 0.277405 */
10200 -6662, /* B1 = -0.406647 */
10201 9090, /* B0 = 0.277405 */
10202 5, /* Internal filter scaling */
10203 159, /* Minimum in-band energy threshold */
10204 21, /* 21/32 in-band to broad-band ratio */
10205 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10206 },
10207 { /* f1000 */
10208 23071, /* A1 = -1.408203 */
10209 -32489, /* A2 = 0.991516 */
10210 -293, /* B2 = -0.008965 */
10211 0, /* B1 = 0.000000 */
10212 293, /* B0 = 0.008965 */
10213 22951, /* A1 = -1.400818 */
10214 -32655, /* A2 = 0.996582 */
10215 5689, /* B2 = 0.173645 */
10216 -3951, /* B1 = -0.241150 */
10217 5689, /* B0 = 0.173645 */
10218 23307, /* A1 = -1.422607 */
10219 -32657, /* A2 = 0.996613 */
10220 18692, /* B2 = 0.570435 */
10221 -13447, /* B1 = -0.820770 */
10222 18692, /* B0 = 0.570435 */
10223 5, /* Internal filter scaling */
10224 159, /* Minimum in-band energy threshold */
10225 21, /* 21/32 in-band to broad-band ratio */
10226 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10227 },
10228 { /* f1020 */
10229 22701, /* A1 = -1.385620 */
10230 -32474, /* A2 = 0.991058 */
10231 -292, /* B2 = -0.008933 */
10232 0, /*163840 , B1 = 10.000000 */
10233 292, /* B0 = 0.008933 */
10234 22564, /* A1 = -1.377258 */
10235 -32655, /* A2 = 0.996552 */
10236 20756, /* B2 = 0.633423 */
10237 -14176, /* B1 = -0.865295 */
10238 20756, /* B0 = 0.633423 */
10239 22960, /* A1 = -1.401428 */
10240 -32657, /* A2 = 0.996613 */
10241 6520, /* B2 = 0.198990 */
10242 -4619, /* B1 = -0.281937 */
10243 6520, /* B0 = 0.198990 */
10244 5, /* Internal filter scaling */
10245 159, /* Minimum in-band energy threshold */
10246 21, /* 21/32 in-band to broad-band ratio */
10247 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10248 },
10249 { /* f1050 */
10250 22142, /* A1 = -1.351501 */
10251 -32474, /* A2 = 0.991058 */
10252 -147, /* B2 = -0.004493 */
10253 0, /* B1 = 0.000000 */
10254 147, /* B0 = 0.004493 */
10255 22000, /* A1 = -1.342834 */
10256 -32655, /* A2 = 0.996552 */
10257 15379, /* B2 = 0.469360 */
10258 -10237, /* B1 = -0.624847 */
10259 15379, /* B0 = 0.469360 */
10260 22406, /* A1 = -1.367554 */
10261 -32657, /* A2 = 0.996613 */
10262 17491, /* B2 = 0.533783 */
10263 -12096, /* B1 = -0.738312 */
10264 17491, /* B0 = 0.533783 */
10265 5, /* Internal filter scaling */
10266 159, /* Minimum in-band energy threshold */
10267 21, /* 21/32 in-band to broad-band ratio */
10268 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10269 },
10270 { /* f1100_1750[] */
10271 12973, /* A1 = 0.79184 */
10272 -24916, /* A2 = -0.760376 */
10273 6655, /* B2 = 0.203102 */
10274 367, /* B1 = 0.0224 */
10275 6657, /* B0 = 0.203171 */
10276 5915, /* A1 = 0.361053 */
10277 -29560, /* A2 = -0.90213 */
10278 -7777, /* B2 = -0.23735 */
10279 0, /* B1 = 0 */
10280 7777, /* B0 = 0.23735 */
10281 20510, /* A1 = 1.251892 */
10282 -30260, /* A2 = -0.923462 */
10283 26662, /* B2 = 0.81366 */
10284 -20573, /* B1 = -1.255737 */
10285 26668, /* B0 = 0.813843 */
10286 7, /* Internal filter scaling */
10287 159, /* Minimum in-band energy threshold */
10288 21, /* 21/32 in-band to broad-band ratio */
10289 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10290 },
10291 { /* f1140 */
10292 20392, /* A1 = -1.244629 */
10293 -32460, /* A2 = 0.990601 */
10294 -270, /* B2 = -0.008240 */
10295 0, /* B1 = 0.000000 */
10296 270, /* B0 = 0.008240 */
10297 20218, /* A1 = -1.234009 */
10298 -32655, /* A2 = 0.996582 */
10299 21337, /* B2 = 0.651154 */
10300 -13044, /* B1 = -0.796143 */
10301 21337, /* B0 = 0.651154 */
10302 20684, /* A1 = -1.262512 */
10303 -32657, /* A2 = 0.996643 */
10304 8572, /* B2 = 0.261612 */
10305 -5476, /* B1 = -0.334244 */
10306 8572, /* B0 = 0.261612 */
10307 5, /* Internal filter scaling */
10308 159, /* Minimum in-band energy threshold */
10309 21, /* 21/32 in-band to broad-band ratio */
10310 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10311 },
10312 { /* f1200 */
10313 19159, /* A1 = -1.169373 */
10314 -32456, /* A2 = 0.990509 */
10315 -335, /* B2 = -0.010252 */
10316 0, /* B1 = 0.000000 */
10317 335, /* B0 = 0.010252 */
10318 18966, /* A1 = -1.157593 */
10319 -32661, /* A2 = 0.996735 */
10320 6802, /* B2 = 0.207588 */
10321 -3900, /* B1 = -0.238098 */
10322 6802, /* B0 = 0.207588 */
10323 19467, /* A1 = -1.188232 */
10324 -32661, /* A2 = 0.996765 */
10325 25035, /* B2 = 0.764008 */
10326 -15049, /* B1 = -0.918579 */
10327 25035, /* B0 = 0.764008 */
10328 5, /* Internal filter scaling */
10329 159, /* Minimum in-band energy threshold */
10330 21, /* 21/32 in-band to broad-band ratio */
10331 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10332 },
10333 { /* f1209 */
10334 18976, /* A1 = -1.158264 */
10335 -32439, /* A2 = 0.989990 */
10336 -183, /* B2 = -0.005588 */
10337 0, /* B1 = 0.000000 */
10338 183, /* B0 = 0.005588 */
10339 18774, /* A1 = -1.145874 */
10340 -32650, /* A2 = 0.996429 */
10341 15468, /* B2 = 0.472076 */
10342 -8768, /* B1 = -0.535217 */
10343 15468, /* B0 = 0.472076 */
10344 19300, /* A1 = -1.177979 */
10345 -32652, /* A2 = 0.996490 */
10346 19840, /* B2 = 0.605499 */
10347 -11842, /* B1 = -0.722809 */
10348 19840, /* B0 = 0.605499 */
10349 5, /* Internal filter scaling */
10350 159, /* Minimum in-band energy threshold */
10351 21, /* 21/32 in-band to broad-band ratio */
10352 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10353 },
10354 { /* f1330 */
10355 16357, /* A1 = -0.998413 */
10356 -32368, /* A2 = 0.987793 */
10357 -217, /* B2 = -0.006652 */
10358 0, /* B1 = 0.000000 */
10359 217, /* B0 = 0.006652 */
10360 16107, /* A1 = -0.983126 */
10361 -32601, /* A2 = 0.994904 */
10362 11602, /* B2 = 0.354065 */
10363 -5555, /* B1 = -0.339111 */
10364 11602, /* B0 = 0.354065 */
10365 16722, /* A1 = -1.020630 */
10366 -32603, /* A2 = 0.994965 */
10367 15574, /* B2 = 0.475311 */
10368 -8176, /* B1 = -0.499069 */
10369 15574, /* B0 = 0.475311 */
10370 5, /* Internal filter scaling */
10371 159, /* Minimum in-band energy threshold */
10372 21, /* 21/32 in-band to broad-band ratio */
10373 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10374 },
10375 { /* f1336 */
10376 16234, /* A1 = -0.990875 */
10377 32404, /* A2 = -0.988922 */
10378 -193, /* B2 = -0.005908 */
10379 0, /* B1 = 0.000000 */
10380 193, /* B0 = 0.005908 */
10381 15986, /* A1 = -0.975769 */
10382 -32632, /* A2 = 0.995880 */
10383 18051, /* B2 = 0.550903 */
10384 -8658, /* B1 = -0.528473 */
10385 18051, /* B0 = 0.550903 */
10386 16591, /* A1 = -1.012695 */
10387 -32634, /* A2 = 0.995941 */
10388 15736, /* B2 = 0.480240 */
10389 -8125, /* B1 = -0.495926 */
10390 15736, /* B0 = 0.480240 */
10391 5, /* Internal filter scaling */
10392 159, /* Minimum in-band energy threshold */
10393 21, /* 21/32 in-band to broad-band ratio */
10394 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10395 },
10396 { /* f1366 */
10397 15564, /* A1 = -0.949982 */
10398 -32404, /* A2 = 0.988922 */
10399 -269, /* B2 = -0.008216 */
10400 0, /* B1 = 0.000000 */
10401 269, /* B0 = 0.008216 */
10402 15310, /* A1 = -0.934479 */
10403 -32632, /* A2 = 0.995880 */
10404 10815, /* B2 = 0.330063 */
10405 -4962, /* B1 = -0.302887 */
10406 10815, /* B0 = 0.330063 */
10407 15924, /* A1 = -0.971924 */
10408 -32634, /* A2 = 0.995941 */
10409 18880, /* B2 = 0.576172 */
10410 -9364, /* B1 = -0.571594 */
10411 18880, /* B0 = 0.576172 */
10412 5, /* Internal filter scaling */
10413 159, /* Minimum in-band energy threshold */
10414 21, /* 21/32 in-band to broad-band ratio */
10415 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10416 },
10417 { /* f1380 */
10418 15247, /* A1 = -0.930603 */
10419 -32397, /* A2 = 0.988708 */
10420 -244, /* B2 = -0.007451 */
10421 0, /* B1 = 0.000000 */
10422 244, /* B0 = 0.007451 */
10423 14989, /* A1 = -0.914886 */
10424 -32627, /* A2 = 0.995697 */
10425 18961, /* B2 = 0.578644 */
10426 -8498, /* B1 = -0.518707 */
10427 18961, /* B0 = 0.578644 */
10428 15608, /* A1 = -0.952667 */
10429 -32628, /* A2 = 0.995758 */
10430 11145, /* B2 = 0.340134 */
10431 -5430, /* B1 = -0.331467 */
10432 11145, /* B0 = 0.340134 */
10433 5, /* Internal filter scaling */
10434 159, /* Minimum in-band energy threshold */
10435 21, /* 21/32 in-band to broad-band ratio */
10436 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10437 },
10438 { /* f1400 */
10439 14780, /* A1 = -0.902130 */
10440 -32393, /* A2 = 0.988586 */
10441 -396, /* B2 = -0.012086 */
10442 0, /* B1 = 0.000000 */
10443 396, /* B0 = 0.012086 */
10444 14510, /* A1 = -0.885651 */
10445 -32630, /* A2 = 0.995819 */
10446 6326, /* B2 = 0.193069 */
10447 -2747, /* B1 = -0.167671 */
10448 6326, /* B0 = 0.193069 */
10449 15154, /* A1 = -0.924957 */
10450 -32632, /* A2 = 0.995850 */
10451 23235, /* B2 = 0.709076 */
10452 -10983, /* B1 = -0.670380 */
10453 23235, /* B0 = 0.709076 */
10454 5, /* Internal filter scaling */
10455 159, /* Minimum in-band energy threshold */
10456 21, /* 21/32 in-band to broad-band ratio */
10457 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10458 },
10459 { /* f1477 */
10460 13005, /* A1 = -0.793793 */
10461 -32368, /* A2 = 0.987823 */
10462 -500, /* B2 = -0.015265 */
10463 0, /* B1 = 0.000000 */
10464 500, /* B0 = 0.015265 */
10465 12708, /* A1 = -0.775665 */
10466 -32615, /* A2 = 0.995331 */
10467 11420, /* B2 = 0.348526 */
10468 -4306, /* B1 = -0.262833 */
10469 11420, /* B0 = 0.348526 */
10470 13397, /* A1 = -0.817688 */
10471 -32615, /* A2 = 0.995361 */
10472 9454, /* B2 = 0.288528 */
10473 -3981, /* B1 = -0.243027 */
10474 9454, /* B0 = 0.288528 */
10475 5, /* Internal filter scaling */
10476 159, /* Minimum in-band energy threshold */
10477 21, /* 21/32 in-band to broad-band ratio */
10478 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10479 },
10480 { /* f1600 */
10481 10046, /* A1 = -0.613190 */
10482 -32331, /* A2 = 0.986694 */
10483 -455, /* B2 = -0.013915 */
10484 0, /* B1 = 0.000000 */
10485 455, /* B0 = 0.013915 */
10486 9694, /* A1 = -0.591705 */
10487 -32601, /* A2 = 0.994934 */
10488 6023, /* B2 = 0.183815 */
10489 -1708, /* B1 = -0.104279 */
10490 6023, /* B0 = 0.183815 */
10491 10478, /* A1 = -0.639587 */
10492 -32603, /* A2 = 0.994965 */
10493 22031, /* B2 = 0.672333 */
10494 -7342, /* B1 = -0.448151 */
10495 22031, /* B0 = 0.672333 */
10496 5, /* Internal filter scaling */
10497 159, /* Minimum in-band energy threshold */
10498 21, /* 21/32 in-band to broad-band ratio */
10499 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10500 },
10501 { /* f1633_1638[] */
10502 9181, /* A1 = 0.560394 */
10503 -32256, /* A2 = -0.984375 */
10504 -556, /* B2 = -0.016975 */
10505 0, /* B1 = 0 */
10506 556, /* B0 = 0.016975 */
10507 8757, /* A1 = 0.534515 */
10508 -32574, /* A2 = -0.99408 */
10509 8443, /* B2 = 0.25769 */
10510 -2135, /* B1 = -0.130341 */
10511 8443, /* B0 = 0.25769 */
10512 9691, /* A1 = 0.591522 */
10513 -32574, /* A2 = -0.99411 */
10514 15446, /* B2 = 0.471375 */
10515 -4809, /* B1 = -0.293579 */
10516 15446, /* B0 = 0.471375 */
10517 7, /* Internal filter scaling */
10518 159, /* Minimum in-band energy threshold */
10519 21, /* 21/32 in-band to broad-band ratio */
10520 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10521 },
10522 { /* f1800 */
10523 5076, /* A1 = -0.309875 */
10524 -32304, /* A2 = 0.985840 */
10525 -508, /* B2 = -0.015503 */
10526 0, /* B1 = 0.000000 */
10527 508, /* B0 = 0.015503 */
10528 4646, /* A1 = -0.283600 */
10529 -32605, /* A2 = 0.995026 */
10530 6742, /* B2 = 0.205780 */
10531 -878, /* B1 = -0.053635 */
10532 6742, /* B0 = 0.205780 */
10533 5552, /* A1 = -0.338928 */
10534 -32605, /* A2 = 0.995056 */
10535 23667, /* B2 = 0.722260 */
10536 -4297, /* B1 = -0.262329 */
10537 23667, /* B0 = 0.722260 */
10538 5, /* Internal filter scaling */
10539 159, /* Minimum in-band energy threshold */
10540 21, /* 21/32 in-band to broad-band ratio */
10541 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10542 },
10543 { /* f1860 */
10544 3569, /* A1 = -0.217865 */
10545 -32292, /* A2 = 0.985504 */
10546 -239, /* B2 = -0.007322 */
10547 0, /* B1 = 0.000000 */
10548 239, /* B0 = 0.007322 */
10549 3117, /* A1 = -0.190277 */
10550 -32603, /* A2 = 0.994965 */
10551 18658, /* B2 = 0.569427 */
10552 -1557, /* B1 = -0.095032 */
10553 18658, /* B0 = 0.569427 */
10554 4054, /* A1 = -0.247437 */
10555 -32603, /* A2 = 0.994965 */
10556 18886, /* B2 = 0.576385 */
10557 -2566, /* B1 = -0.156647 */
10558 18886, /* B0 = 0.576385 */
10559 5, /* Internal filter scaling */
10560 159, /* Minimum in-band energy threshold */
10561 21, /* 21/32 in-band to broad-band ratio */
10562 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10563 },
10564 };
10565 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10566 {
10567 unsigned short cmd;
10568 int cnt, max;
10569
10570 if (jf->filter > 3) {
10571 return -1;
10572 }
10573 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10574
10575 return -1;
10576 if (!jf->enable) {
10577 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10578
10579 return -1;
10580 else
10581 return 0;
10582 } else {
10583 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10584
10585 return -1;
10586 /* Select the filter (f0 - f3) to use. */
10587 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10588 return -1;
10589 }
10590 if (jf->freq < 12 && jf->freq > 3) {
10591 /* Select the frequency for the selected filter. */
10592 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10593 return -1;
10594 } else if (jf->freq > 11) {
10595 /* We need to load a programmable filter set for undefined */
10596 /* frequencies. So we will point the filter to a programmable set. */
10597 /* Since there are only 4 filters and 4 programmable sets, we will */
10598 /* just point the filter to the same number set and program it for the */
10599 /* frequency we want. */
10600 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10601 return -1;
10602 if (j->ver.low != 0x12) {
10603 cmd = 0x515B;
10604 max = 19;
10605 } else {
10606 cmd = 0x515E;
10607 max = 15;
10608 }
10609 if (ixj_WriteDSPCommand(cmd, j))
10610 return -1;
10611 for (cnt = 0; cnt < max; cnt++) {
10612 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10613 return -1;
10614 }
10615 }
10616 j->filter_en[jf->filter] = jf->enable;
10617 return 0;
10618 }
10619
10620 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10621 {
10622 unsigned short cmd;
10623 int cnt, max;
10624 if (jfr->filter > 3) {
10625 return -1;
10626 }
10627 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10628 return -1;
10629
10630 if (!jfr->enable) {
10631 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10632 return -1;
10633 else
10634 return 0;
10635 } else {
10636 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10637 return -1;
10638 /* Select the filter (f0 - f3) to use. */
10639 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10640 return -1;
10641 }
10642 /* We need to load a programmable filter set for undefined */
10643 /* frequencies. So we will point the filter to a programmable set. */
10644 /* Since there are only 4 filters and 4 programmable sets, we will */
10645 /* just point the filter to the same number set and program it for the */
10646 /* frequency we want. */
10647 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10648 return -1;
10649 if (j->ver.low != 0x12) {
10650 cmd = 0x515B;
10651 max = 19;
10652 } else {
10653 cmd = 0x515E;
10654 max = 15;
10655 }
10656 if (ixj_WriteDSPCommand(cmd, j))
10657 return -1;
10658 for (cnt = 0; cnt < max; cnt++) {
10659 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10660 return -1;
10661 }
10662 j->filter_en[jfr->filter] = jfr->enable;
10663 return 0;
10664 }
10665
10666 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10667 {
10668 int freq0, freq1;
10669 unsigned short data;
10670 if (ti->freq0) {
10671 freq0 = ti->freq0;
10672 } else {
10673 freq0 = 0x7FFF;
10674 }
10675
10676 if (ti->freq1) {
10677 freq1 = ti->freq1;
10678 } else {
10679 freq1 = 0x7FFF;
10680 }
10681
10682 if(ti->tone_index > 12 && ti->tone_index < 28)
10683 {
10684 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10685 return -1;
10686 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10687 return -1;
10688 data = freq0;
10689 if (ixj_WriteDSPCommand(data, j))
10690 return -1;
10691 data = freq1;
10692 if (ixj_WriteDSPCommand(data, j))
10693 return -1;
10694 }
10695 return freq0;
10696 }
10697
MOXA 2.6.9 from sdlinux-moxaart.tgz