?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vlan: Rename VLAN_GROUP_ARRAY_LEN to VLAN_N_VID.
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / telephony / ixj.c
blobb53deee25d74d525faa4692e3539af0cd3ceb369
1 /****************************************************************************
2 * ixj.c
3 *
4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
7 * SmartCABLE
8 *
9 * (c) Copyright 1999-2001 Quicknet Technologies, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Author: Ed Okerson, <eokerson@quicknet.net>
17 *
18 * Contributors: Greg Herlein, <gherlein@quicknet.net>
19 * David W. Erhart, <derhart@quicknet.net>
20 * John Sellers, <jsellers@quicknet.net>
21 * Mike Preston, <mpreston@quicknet.net>
22 *
23 * Fixes: David Huggins-Daines, <dhd@cepstral.com>
24 * Fabio Ferrari, <fabio.ferrari@digitro.com.br>
25 * Artis Kugevics, <artis@mt.lv>
26 * Daniele Bellucci, <bellucda@tiscali.it>
27 *
28 * More information about the hardware related to this driver can be found
29 * at our website: http://www.quicknet.net
30 *
31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
41 *
42 ***************************************************************************/
43
44 /*
45 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
46 * Audit some copy_*_user and minor cleanup.
47 *
48 * Revision 4.7 2001/08/13 06:19:33 craigs
49 * Added additional changes from Alan Cox and John Anderson for
50 * 2.2 to 2.4 cleanup and bounds checking
51 *
52 * Revision 4.6 2001/08/13 01:05:05 craigs
53 * Really fixed PHONE_QUERY_CODEC problem this time
54 *
55 * Revision 4.5 2001/08/13 00:11:03 craigs
56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57 *
58 * Revision 4.4 2001/08/07 07:58:12 craigs
59 * Changed back to three digit version numbers
60 * Added tagbuild target to allow automatic and easy tagging of versions
61 *
62 * Revision 4.3 2001/08/07 07:24:47 craigs
63 * Added ixj-ver.h to allow easy configuration management of driver
64 * Added display of version number in /prox/ixj
65 *
66 * Revision 4.2 2001/08/06 07:07:19 craigs
67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68 * behaviour of returning int rather than short *
69 *
70 * Revision 4.1 2001/08/05 00:17:37 craigs
71 * More changes for correct PCMCIA installation
72 * Start of changes for backward Linux compatibility
73 *
74 * Revision 4.0 2001/08/04 12:33:12 craigs
75 * New version using GNU autoconf
76 *
77 * Revision 3.105 2001/07/20 23:14:32 eokerson
78 * More work on CallerID generation when using ring cadences.
79 *
80 * Revision 3.104 2001/07/06 01:33:55 eokerson
81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
82 *
83 * Revision 3.103 2001/07/05 19:20:16 eokerson
84 * Updated HOWTO
85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86 *
87 * Revision 3.102 2001/07/03 23:51:21 eokerson
88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
89 *
90 * Revision 3.101 2001/07/02 19:26:56 eokerson
91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92 *
93 * Revision 3.100 2001/07/02 19:18:27 eokerson
94 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96 * Fixed speaker mode on Internet LineJACK.
97 *
98 * Revision 3.99 2001/05/09 14:11:16 eokerson
99 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
100 *
101 * Revision 3.98 2001/05/08 19:55:33 eokerson
102 * Fixed POTS hookstate detection while it is connected to PSTN port.
103 *
104 * Revision 3.97 2001/05/08 00:01:04 eokerson
105 * Fixed kernel oops when sending caller ID data.
106 *
107 * Revision 3.96 2001/05/04 23:09:30 eokerson
108 * Now uses one kernel timer for each card, instead of one for the entire driver.
109 *
110 * Revision 3.95 2001/04/25 22:06:47 eokerson
111 * Fixed squawking at beginning of some G.723.1 calls.
112 *
113 * Revision 3.94 2001/04/03 23:42:00 eokerson
114 * Added linear volume ioctls
115 * Added raw filter load ioctl
116 *
117 * Revision 3.93 2001/02/27 01:00:06 eokerson
118 * Fixed blocking in CallerID.
119 * Reduced size of ixj structure for smaller driver footprint.
120 *
121 * Revision 3.92 2001/02/20 22:02:59 eokerson
122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123 * Improved PSTN ring detection.
124 * Fixed wink generation on POTS ports.
125 *
126 * Revision 3.91 2001/02/13 00:55:44 eokerson
127 * Turn AEC back on after changing frame sizes.
128 *
129 * Revision 3.90 2001/02/12 16:42:00 eokerson
130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131 *
132 * Revision 3.89 2001/02/12 15:41:16 eokerson
133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
134 *
135 * Revision 3.88 2001/02/05 23:25:42 eokerson
136 * Fixed lockup bugs with deregister.
137 *
138 * Revision 3.87 2001/01/29 21:00:39 eokerson
139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
140 * Updated copyright date.
141 *
142 * Revision 3.86 2001/01/23 23:53:46 eokerson
143 * Fixes to G.729 compatibility.
144 *
145 * Revision 3.85 2001/01/23 21:30:36 eokerson
146 * Added verbage about cards supported.
147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148 *
149 * Revision 3.84 2001/01/22 23:32:10 eokerson
150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
151 *
152 * Revision 3.83 2001/01/19 14:51:41 eokerson
153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154 *
155 * Revision 3.82 2001/01/19 00:34:49 eokerson
156 * Added verbosity to write overlap errors.
157 *
158 * Revision 3.81 2001/01/18 23:56:54 eokerson
159 * Fixed PSTN line test functions.
160 *
161 * Revision 3.80 2001/01/18 22:29:27 eokerson
162 * Updated AEC/AGC values for different cards.
163 *
164 * Revision 3.79 2001/01/17 02:58:54 eokerson
165 * Fixed AEC reset after Caller ID.
166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167 *
168 * Revision 3.78 2001/01/16 19:43:09 eokerson
169 * Added support for Linux 2.4.x kernels.
170 *
171 * Revision 3.77 2001/01/09 04:00:52 eokerson
172 * Linetest will now test the line, even if it has previously succeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246 #include "ixj-ver.h"
247
248 #define PERFMON_STATS
249 #define IXJDEBUG 0
250 #define MAXRINGS 5
251
252 #include <linux/module.h>
253
254 #include <linux/init.h>
255 #include <linux/sched.h>
256 #include <linux/kernel.h> /* printk() */
257 #include <linux/fs.h> /* everything... */
258 #include <linux/errno.h> /* error codes */
259 #include <linux/slab.h>
260 #include <linux/smp_lock.h>
261 #include <linux/mm.h>
262 #include <linux/ioport.h>
263 #include <linux/interrupt.h>
264 #include <linux/proc_fs.h>
265 #include <linux/poll.h>
266 #include <linux/timer.h>
267 #include <linux/delay.h>
268 #include <linux/pci.h>
269
270 #include <asm/io.h>
271 #include <asm/uaccess.h>
272
273 #include <linux/isapnp.h>
274
275 #include "ixj.h"
276
277 #define TYPE(inode) (iminor(inode) >> 4)
278 #define NUM(inode) (iminor(inode) & 0xf)
279
280 static int ixjdebug;
281 static int hertz = HZ;
282 static int samplerate = 100;
283
284 module_param(ixjdebug, int, 0);
285
286 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
287 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
288 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
289 { }
290 };
291
292 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
293
294 /************************************************************************
295 *
296 * ixjdebug meanings are now bit mapped instead of level based
297 * Values can be or'ed together to turn on multiple messages
298 *
299 * bit 0 (0x0001) = any failure
300 * bit 1 (0x0002) = general messages
301 * bit 2 (0x0004) = POTS ringing related
302 * bit 3 (0x0008) = PSTN events
303 * bit 4 (0x0010) = PSTN Cadence state details
304 * bit 5 (0x0020) = Tone detection triggers
305 * bit 6 (0x0040) = Tone detection cadence details
306 * bit 7 (0x0080) = ioctl tracking
307 * bit 8 (0x0100) = signal tracking
308 * bit 9 (0x0200) = CallerID generation details
309 *
310 ************************************************************************/
311
312 #ifdef IXJ_DYN_ALLOC
313
314 static IXJ *ixj[IXJMAX];
315 #define get_ixj(b) ixj[(b)]
316
317 /*
318 * Allocate a free IXJ device
319 */
320
321 static IXJ *ixj_alloc()
322 {
323 for(cnt=0; cnt<IXJMAX; cnt++)
324 {
325 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
326 {
327 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
328 if (j == NULL)
329 return NULL;
330 ixj[cnt] = j;
331 return j;
332 }
333 }
334 return NULL;
335 }
336
337 static void ixj_fsk_free(IXJ *j)
338 {
339 kfree(j->fskdata);
340 j->fskdata = NULL;
341 }
342
343 static void ixj_fsk_alloc(IXJ *j)
344 {
345 if(!j->fskdata) {
346 j->fskdata = kmalloc(8000, GFP_KERNEL);
347 if (!j->fskdata) {
348 if(ixjdebug & 0x0200) {
349 printk("IXJ phone%d - allocate failed\n", j->board);
350 }
351 return;
352 } else {
353 j->fsksize = 8000;
354 if(ixjdebug & 0x0200) {
355 printk("IXJ phone%d - allocate succeded\n", j->board);
356 }
357 }
358 }
359 }
360
361 #else
362
363 static IXJ ixj[IXJMAX];
364 #define get_ixj(b) (&ixj[(b)])
365
366 /*
367 * Allocate a free IXJ device
368 */
369
370 static IXJ *ixj_alloc(void)
371 {
372 int cnt;
373 for(cnt=0; cnt<IXJMAX; cnt++) {
374 if(!ixj[cnt].DSPbase)
375 return &ixj[cnt];
376 }
377 return NULL;
378 }
379
380 static inline void ixj_fsk_free(IXJ *j) {;}
381
382 static inline void ixj_fsk_alloc(IXJ *j)
383 {
384 j->fsksize = 8000;
385 }
386
387 #endif
388
389 #ifdef PERFMON_STATS
390 #define ixj_perfmon(x) ((x)++)
391 #else
392 #define ixj_perfmon(x) do { } while(0)
393 #endif
394
395 static int ixj_convert_loaded;
396
397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
398
399 /************************************************************************
400 *
401 * These are function definitions to allow external modules to register
402 * enhanced functionality call backs.
403 *
404 ************************************************************************/
405
406 static int Stub(IXJ * J, unsigned long arg)
407 {
408 return 0;
409 }
410
411 static IXJ_REGFUNC ixj_PreRead = &Stub;
412 static IXJ_REGFUNC ixj_PostRead = &Stub;
413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
415
416 static void ixj_read_frame(IXJ *j);
417 static void ixj_write_frame(IXJ *j);
418 static void ixj_init_timer(IXJ *j);
419 static void ixj_add_timer(IXJ * j);
420 static void ixj_timeout(unsigned long ptr);
421 static int read_filters(IXJ *j);
422 static int LineMonitor(IXJ *j);
423 static int ixj_fasync(int fd, struct file *, int mode);
424 static int ixj_set_port(IXJ *j, int arg);
425 static int ixj_set_pots(IXJ *j, int arg);
426 static int ixj_hookstate(IXJ *j);
427 static int ixj_record_start(IXJ *j);
428 static void ixj_record_stop(IXJ *j);
429 static void set_rec_volume(IXJ *j, int volume);
430 static int get_rec_volume(IXJ *j);
431 static int set_rec_codec(IXJ *j, int rate);
432 static void ixj_vad(IXJ *j, int arg);
433 static int ixj_play_start(IXJ *j);
434 static void ixj_play_stop(IXJ *j);
435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
436 static int ixj_set_tone_off(unsigned short, IXJ *j);
437 static int ixj_play_tone(IXJ *j, char tone);
438 static void ixj_aec_start(IXJ *j, int level);
439 static int idle(IXJ *j);
440 static void ixj_ring_on(IXJ *j);
441 static void ixj_ring_off(IXJ *j);
442 static void aec_stop(IXJ *j);
443 static void ixj_ringback(IXJ *j);
444 static void ixj_busytone(IXJ *j);
445 static void ixj_dialtone(IXJ *j);
446 static void ixj_cpt_stop(IXJ *j);
447 static char daa_int_read(IXJ *j);
448 static char daa_CR_read(IXJ *j, int cr);
449 static int daa_set_mode(IXJ *j, int mode);
450 static int ixj_linetest(IXJ *j);
451 static int ixj_daa_write(IXJ *j);
452 static int ixj_daa_cid_read(IXJ *j);
453 static void DAA_Coeff_US(IXJ *j);
454 static void DAA_Coeff_UK(IXJ *j);
455 static void DAA_Coeff_France(IXJ *j);
456 static void DAA_Coeff_Germany(IXJ *j);
457 static void DAA_Coeff_Australia(IXJ *j);
458 static void DAA_Coeff_Japan(IXJ *j);
459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
464 /* Serial Control Interface funtions */
465 static int SCI_Control(IXJ *j, int control);
466 static int SCI_Prepare(IXJ *j);
467 static int SCI_WaitHighSCI(IXJ *j);
468 static int SCI_WaitLowSCI(IXJ *j);
469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
470 static int ixj_PCcontrol_wait(IXJ *j);
471 static void ixj_pre_cid(IXJ *j);
472 static void ixj_write_cid(IXJ *j);
473 static void ixj_write_cid_bit(IXJ *j, int bit);
474 static int set_base_frame(IXJ *j, int size);
475 static int set_play_codec(IXJ *j, int rate);
476 static void set_rec_depth(IXJ *j, int depth);
477 static int ixj_mixer(long val, IXJ *j);
478
479 /************************************************************************
480 CT8020/CT8021 Host Programmers Model
481 Host address Function Access
482 DSPbase +
483 0-1 Aux Software Status Register (reserved) Read Only
484 2-3 Software Status Register Read Only
485 4-5 Aux Software Control Register (reserved) Read Write
486 6-7 Software Control Register Read Write
487 8-9 Hardware Status Register Read Only
488 A-B Hardware Control Register Read Write
489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
490 E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
491 ************************************************************************/
492
493 static inline void ixj_read_HSR(IXJ *j)
494 {
495 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
496 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
497 }
498
499 static inline int IsControlReady(IXJ *j)
500 {
501 ixj_read_HSR(j);
502 return j->hsr.bits.controlrdy ? 1 : 0;
503 }
504
505 static inline int IsPCControlReady(IXJ *j)
506 {
507 j->pccr1.byte = inb_p(j->XILINXbase + 3);
508 return j->pccr1.bits.crr ? 1 : 0;
509 }
510
511 static inline int IsStatusReady(IXJ *j)
512 {
513 ixj_read_HSR(j);
514 return j->hsr.bits.statusrdy ? 1 : 0;
515 }
516
517 static inline int IsRxReady(IXJ *j)
518 {
519 ixj_read_HSR(j);
520 ixj_perfmon(j->rxreadycheck);
521 return j->hsr.bits.rxrdy ? 1 : 0;
522 }
523
524 static inline int IsTxReady(IXJ *j)
525 {
526 ixj_read_HSR(j);
527 ixj_perfmon(j->txreadycheck);
528 return j->hsr.bits.txrdy ? 1 : 0;
529 }
530
531 static inline void set_play_volume(IXJ *j, int volume)
532 {
533 if (ixjdebug & 0x0002)
534 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
535 ixj_WriteDSPCommand(0xCF02, j);
536 ixj_WriteDSPCommand(volume, j);
537 }
538
539 static int set_play_volume_linear(IXJ *j, int volume)
540 {
541 int newvolume, dspplaymax;
542
543 if (ixjdebug & 0x0002)
544 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
545 if(volume > 100 || volume < 0) {
546 return -1;
547 }
548
549 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
550 switch (j->cardtype) {
551 case QTI_PHONEJACK:
552 dspplaymax = 0x380;
553 break;
554 case QTI_LINEJACK:
555 if(j->port == PORT_PSTN) {
556 dspplaymax = 0x48;
557 } else {
558 dspplaymax = 0x100;
559 }
560 break;
561 case QTI_PHONEJACK_LITE:
562 dspplaymax = 0x380;
563 break;
564 case QTI_PHONEJACK_PCI:
565 dspplaymax = 0x6C;
566 break;
567 case QTI_PHONECARD:
568 dspplaymax = 0x50;
569 break;
570 default:
571 return -1;
572 }
573 newvolume = (dspplaymax * volume) / 100;
574 set_play_volume(j, newvolume);
575 return 0;
576 }
577
578 static inline void set_play_depth(IXJ *j, int depth)
579 {
580 if (depth > 60)
581 depth = 60;
582 if (depth < 0)
583 depth = 0;
584 ixj_WriteDSPCommand(0x5280 + depth, j);
585 }
586
587 static inline int get_play_volume(IXJ *j)
588 {
589 ixj_WriteDSPCommand(0xCF00, j);
590 return j->ssr.high << 8 | j->ssr.low;
591 }
592
593 static int get_play_volume_linear(IXJ *j)
594 {
595 int volume, newvolume, dspplaymax;
596
597 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
598 switch (j->cardtype) {
599 case QTI_PHONEJACK:
600 dspplaymax = 0x380;
601 break;
602 case QTI_LINEJACK:
603 if(j->port == PORT_PSTN) {
604 dspplaymax = 0x48;
605 } else {
606 dspplaymax = 0x100;
607 }
608 break;
609 case QTI_PHONEJACK_LITE:
610 dspplaymax = 0x380;
611 break;
612 case QTI_PHONEJACK_PCI:
613 dspplaymax = 0x6C;
614 break;
615 case QTI_PHONECARD:
616 dspplaymax = 100;
617 break;
618 default:
619 return -1;
620 }
621 volume = get_play_volume(j);
622 newvolume = (volume * 100) / dspplaymax;
623 if(newvolume > 100)
624 newvolume = 100;
625 return newvolume;
626 }
627
628 static inline BYTE SLIC_GetState(IXJ *j)
629 {
630 if (j->cardtype == QTI_PHONECARD) {
631 j->pccr1.byte = 0;
632 j->psccr.bits.dev = 3;
633 j->psccr.bits.rw = 1;
634 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
635 ixj_PCcontrol_wait(j);
636 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
637 ixj_PCcontrol_wait(j);
638 if (j->pslic.bits.powerdown)
639 return PLD_SLIC_STATE_OC;
640 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
641 return PLD_SLIC_STATE_ACTIVE;
642 else
643 return PLD_SLIC_STATE_RINGING;
644 } else {
645 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
646 }
647 return j->pld_slicr.bits.state;
648 }
649
650 static bool SLIC_SetState(BYTE byState, IXJ *j)
651 {
652 bool fRetVal = false;
653
654 if (j->cardtype == QTI_PHONECARD) {
655 if (j->flags.pcmciasct) {
656 switch (byState) {
657 case PLD_SLIC_STATE_TIPOPEN:
658 case PLD_SLIC_STATE_OC:
659 j->pslic.bits.powerdown = 1;
660 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
661 fRetVal = true;
662 break;
663 case PLD_SLIC_STATE_RINGING:
664 if (j->readers || j->writers) {
665 j->pslic.bits.powerdown = 0;
666 j->pslic.bits.ring0 = 1;
667 j->pslic.bits.ring1 = 0;
668 fRetVal = true;
669 }
670 break;
671 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
672
673 case PLD_SLIC_STATE_STANDBY:
674 case PLD_SLIC_STATE_ACTIVE:
675 if (j->readers || j->writers) {
676 j->pslic.bits.powerdown = 0;
677 } else {
678 j->pslic.bits.powerdown = 1;
679 }
680 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
681 fRetVal = true;
682 break;
683 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
684
685 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
686
687 default:
688 fRetVal = false;
689 break;
690 }
691 j->psccr.bits.dev = 3;
692 j->psccr.bits.rw = 0;
693 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
694 ixj_PCcontrol_wait(j);
695 }
696 } else {
697 /* Set the C1, C2, C3 & B2EN signals. */
698 switch (byState) {
699 case PLD_SLIC_STATE_OC:
700 j->pld_slicw.bits.c1 = 0;
701 j->pld_slicw.bits.c2 = 0;
702 j->pld_slicw.bits.c3 = 0;
703 j->pld_slicw.bits.b2en = 0;
704 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
705 fRetVal = true;
706 break;
707 case PLD_SLIC_STATE_RINGING:
708 j->pld_slicw.bits.c1 = 1;
709 j->pld_slicw.bits.c2 = 0;
710 j->pld_slicw.bits.c3 = 0;
711 j->pld_slicw.bits.b2en = 1;
712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
713 fRetVal = true;
714 break;
715 case PLD_SLIC_STATE_ACTIVE:
716 j->pld_slicw.bits.c1 = 0;
717 j->pld_slicw.bits.c2 = 1;
718 j->pld_slicw.bits.c3 = 0;
719 j->pld_slicw.bits.b2en = 0;
720 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
721 fRetVal = true;
722 break;
723 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
724
725 j->pld_slicw.bits.c1 = 1;
726 j->pld_slicw.bits.c2 = 1;
727 j->pld_slicw.bits.c3 = 0;
728 j->pld_slicw.bits.b2en = 0;
729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
730 fRetVal = true;
731 break;
732 case PLD_SLIC_STATE_TIPOPEN:
733 j->pld_slicw.bits.c1 = 0;
734 j->pld_slicw.bits.c2 = 0;
735 j->pld_slicw.bits.c3 = 1;
736 j->pld_slicw.bits.b2en = 0;
737 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
738 fRetVal = true;
739 break;
740 case PLD_SLIC_STATE_STANDBY:
741 j->pld_slicw.bits.c1 = 1;
742 j->pld_slicw.bits.c2 = 0;
743 j->pld_slicw.bits.c3 = 1;
744 j->pld_slicw.bits.b2en = 1;
745 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
746 fRetVal = true;
747 break;
748 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
749
750 j->pld_slicw.bits.c1 = 0;
751 j->pld_slicw.bits.c2 = 1;
752 j->pld_slicw.bits.c3 = 1;
753 j->pld_slicw.bits.b2en = 0;
754 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
755 fRetVal = true;
756 break;
757 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
758
759 j->pld_slicw.bits.c1 = 1;
760 j->pld_slicw.bits.c2 = 1;
761 j->pld_slicw.bits.c3 = 1;
762 j->pld_slicw.bits.b2en = 0;
763 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
764 fRetVal = true;
765 break;
766 default:
767 fRetVal = false;
768 break;
769 }
770 }
771
772 return fRetVal;
773 }
774
775 static int ixj_wink(IXJ *j)
776 {
777 BYTE slicnow;
778
779 slicnow = SLIC_GetState(j);
780
781 j->pots_winkstart = jiffies;
782 SLIC_SetState(PLD_SLIC_STATE_OC, j);
783
784 msleep(jiffies_to_msecs(j->winktime));
785
786 SLIC_SetState(slicnow, j);
787 return 0;
788 }
789
790 static void ixj_init_timer(IXJ *j)
791 {
792 init_timer(&j->timer);
793 j->timer.function = ixj_timeout;
794 j->timer.data = (unsigned long)j;
795 }
796
797 static void ixj_add_timer(IXJ *j)
798 {
799 j->timer.expires = jiffies + (hertz / samplerate);
800 add_timer(&j->timer);
801 }
802
803 static void ixj_tone_timeout(IXJ *j)
804 {
805 IXJ_TONE ti;
806
807 j->tone_state++;
808 if (j->tone_state == 3) {
809 j->tone_state = 0;
810 if (j->cadence_t) {
811 j->tone_cadence_state++;
812 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
813 switch (j->cadence_t->termination) {
814 case PLAY_ONCE:
815 ixj_cpt_stop(j);
816 break;
817 case REPEAT_LAST_ELEMENT:
818 j->tone_cadence_state--;
819 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
820 break;
821 case REPEAT_ALL:
822 j->tone_cadence_state = 0;
823 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
824 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
825 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
826 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
827 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
828 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
829 ixj_init_tone(j, &ti);
830 }
831 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
832 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
833 ixj_play_tone(j, j->cadence_t->ce[0].index);
834 break;
835 }
836 } else {
837 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
838 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
839 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
840 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
841 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
842 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
843 ixj_init_tone(j, &ti);
844 }
845 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
846 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
847 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
848 }
849 }
850 }
851 }
852
853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
854 {
855 if(j->ixj_signals[event]) {
856 if(ixjdebug & 0x0100)
857 printk("Sending signal for event %d\n", event);
858 /* Send apps notice of change */
859 /* see config.h for macro definition */
860 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
861 }
862 }
863
864 static void ixj_pstn_state(IXJ *j)
865 {
866 int var;
867 union XOPXR0 XR0, daaint;
868
869 var = 10;
870
871 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
872 daaint.reg = 0;
873 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
874
875 j->pld_scrr.byte = inb_p(j->XILINXbase);
876 if (j->pld_scrr.bits.daaflag) {
877 daa_int_read(j);
878 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
879 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
880 daaint.bitreg.RING = 1;
881 if(ixjdebug & 0x0008) {
882 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
883 }
884 } else {
885 daa_set_mode(j, SOP_PU_RESET);
886 }
887 }
888 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
889 daaint.bitreg.Caller_ID = 1;
890 j->pstn_cid_intr = 1;
891 j->pstn_cid_received = jiffies;
892 if(ixjdebug & 0x0008) {
893 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
894 }
895 }
896 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
897 daaint.bitreg.Cadence = 1;
898 if(ixjdebug & 0x0008) {
899 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
900 }
901 }
902 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
903 daaint.bitreg.VDD_OK = 1;
904 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
905 }
906 }
907 daa_CR_read(j, 1);
908 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
909 daaint.bitreg.RMR = 1;
910 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
911 if(ixjdebug & 0x0008) {
912 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
913 }
914 j->pstn_prev_rmr = j->pstn_last_rmr;
915 j->pstn_last_rmr = jiffies;
916 }
917 switch(j->daa_mode) {
918 case SOP_PU_SLEEP:
919 if (daaint.bitreg.RING) {
920 if (!j->flags.pstn_ringing) {
921 if (j->daa_mode != SOP_PU_RINGING) {
922 j->pstn_ring_int = jiffies;
923 daa_set_mode(j, SOP_PU_RINGING);
924 }
925 }
926 }
927 break;
928 case SOP_PU_RINGING:
929 if (daaint.bitreg.RMR) {
930 if (ixjdebug & 0x0008) {
931 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
932 }
933 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
934 j->flags.pstn_rmr = 1;
935 j->pstn_ring_start = jiffies;
936 j->pstn_ring_stop = 0;
937 j->ex.bits.pstn_ring = 0;
938 if (j->cadence_f[4].state == 0) {
939 j->cadence_f[4].state = 1;
940 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
941 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
942 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
943 } else if (j->cadence_f[4].state == 2) {
944 if((time_after(jiffies, j->cadence_f[4].off1min) &&
945 time_before(jiffies, j->cadence_f[4].off1max))) {
946 if (j->cadence_f[4].on2) {
947 j->cadence_f[4].state = 3;
948 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
949 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
950 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
951 } else {
952 j->cadence_f[4].state = 7;
953 }
954 } else {
955 if (ixjdebug & 0x0008) {
956 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
957 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
958 j->cadence_f[4].off1);
959 }
960 j->cadence_f[4].state = 0;
961 }
962 } else if (j->cadence_f[4].state == 4) {
963 if((time_after(jiffies, j->cadence_f[4].off2min) &&
964 time_before(jiffies, j->cadence_f[4].off2max))) {
965 if (j->cadence_f[4].on3) {
966 j->cadence_f[4].state = 5;
967 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
968 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
969 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
970 } else {
971 j->cadence_f[4].state = 7;
972 }
973 } else {
974 if (ixjdebug & 0x0008) {
975 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
976 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
977 j->cadence_f[4].off2);
978 }
979 j->cadence_f[4].state = 0;
980 }
981 } else if (j->cadence_f[4].state == 6) {
982 if((time_after(jiffies, j->cadence_f[4].off3min) &&
983 time_before(jiffies, j->cadence_f[4].off3max))) {
984 j->cadence_f[4].state = 7;
985 } else {
986 if (ixjdebug & 0x0008) {
987 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
988 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
989 j->cadence_f[4].off3);
990 }
991 j->cadence_f[4].state = 0;
992 }
993 } else {
994 j->cadence_f[4].state = 0;
995 }
996 } else { /* Falling edge of RMR */
997 j->pstn_ring_start = 0;
998 j->pstn_ring_stop = jiffies;
999 if (j->cadence_f[4].state == 1) {
1000 if(!j->cadence_f[4].on1) {
1001 j->cadence_f[4].state = 7;
1002 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003 time_before(jiffies, j->cadence_f[4].on1max))) {
1004 if (j->cadence_f[4].off1) {
1005 j->cadence_f[4].state = 2;
1006 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009 } else {
1010 j->cadence_f[4].state = 7;
1011 }
1012 } else {
1013 if (ixjdebug & 0x0008) {
1014 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016 j->cadence_f[4].on1);
1017 }
1018 j->cadence_f[4].state = 0;
1019 }
1020 } else if (j->cadence_f[4].state == 3) {
1021 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022 time_before(jiffies, j->cadence_f[4].on2max))) {
1023 if (j->cadence_f[4].off2) {
1024 j->cadence_f[4].state = 4;
1025 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028 } else {
1029 j->cadence_f[4].state = 7;
1030 }
1031 } else {
1032 if (ixjdebug & 0x0008) {
1033 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035 j->cadence_f[4].on2);
1036 }
1037 j->cadence_f[4].state = 0;
1038 }
1039 } else if (j->cadence_f[4].state == 5) {
1040 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041 time_before(jiffies, j->cadence_f[4].on3max))) {
1042 if (j->cadence_f[4].off3) {
1043 j->cadence_f[4].state = 6;
1044 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047 } else {
1048 j->cadence_f[4].state = 7;
1049 }
1050 } else {
1051 j->cadence_f[4].state = 0;
1052 }
1053 } else {
1054 if (ixjdebug & 0x0008) {
1055 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057 j->cadence_f[4].on3);
1058 }
1059 j->cadence_f[4].state = 0;
1060 }
1061 }
1062 if (ixjdebug & 0x0010) {
1063 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064 }
1065 if (ixjdebug & 0x0010) {
1066 switch(j->cadence_f[4].state) {
1067 case 1:
1068 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070 break;
1071 case 2:
1072 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074 break;
1075 case 3:
1076 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078 break;
1079 case 4:
1080 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082 break;
1083 case 5:
1084 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086 break;
1087 case 6:
1088 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090 break;
1091 }
1092 }
1093 }
1094 if (j->cadence_f[4].state == 7) {
1095 j->cadence_f[4].state = 0;
1096 j->pstn_ring_stop = jiffies;
1097 j->ex.bits.pstn_ring = 1;
1098 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099 if(ixjdebug & 0x0008) {
1100 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101 }
1102 }
1103 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105 if(ixjdebug & 0x0008) {
1106 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109 }
1110 j->pstn_ring_stop = j->pstn_ring_int = 0;
1111 daa_set_mode(j, SOP_PU_SLEEP);
1112 }
1113 outb_p(j->pld_scrw.byte, j->XILINXbase);
1114 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115 ixj_daa_cid_read(j);
1116 j->ex.bits.caller_id = 1;
1117 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118 j->pstn_cid_intr = 0;
1119 }
1120 if (daaint.bitreg.Cadence) {
1121 if(ixjdebug & 0x0008) {
1122 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123 }
1124 daa_set_mode(j, SOP_PU_SLEEP);
1125 j->ex.bits.pstn_ring = 0;
1126 }
1127 break;
1128 case SOP_PU_CONVERSATION:
1129 if (daaint.bitreg.VDD_OK) {
1130 if(!daaint.bitreg.SI_0) {
1131 if (!j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = jiffies;
1136 }
1137 } else {
1138 if (j->pstn_winkstart) {
1139 if(ixjdebug & 0x0008) {
1140 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141 }
1142 j->pstn_winkstart = 0;
1143 }
1144 }
1145 }
1146 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147 if(ixjdebug & 0x0008) {
1148 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149 }
1150 daa_set_mode(j, SOP_PU_SLEEP);
1151 j->pstn_winkstart = 0;
1152 j->ex.bits.pstn_wink = 1;
1153 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154 }
1155 break;
1156 }
1157 }
1158
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161 int board;
1162 unsigned long jifon;
1163 IXJ *j = (IXJ *)ptr;
1164 board = j->board;
1165
1166 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167 ixj_perfmon(j->timerchecks);
1168 j->hookstate = ixj_hookstate(j);
1169 if (j->tone_state) {
1170 if (!(j->hookstate)) {
1171 ixj_cpt_stop(j);
1172 if (j->m_hook) {
1173 j->m_hook = 0;
1174 j->ex.bits.hookstate = 1;
1175 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176 }
1177 clear_bit(board, &j->busyflags);
1178 ixj_add_timer(j);
1179 return;
1180 }
1181 if (j->tone_state == 1)
1182 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183 else
1184 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186 if (j->tone_state == 1) {
1187 ixj_play_tone(j, j->tone_index);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 } else {
1194 ixj_play_tone(j, 0);
1195 if (j->dsp.low == 0x20) {
1196 clear_bit(board, &j->busyflags);
1197 ixj_add_timer(j);
1198 return;
1199 }
1200 }
1201 } else {
1202 ixj_tone_timeout(j);
1203 if (j->flags.dialtone) {
1204 ixj_dialtone(j);
1205 }
1206 if (j->flags.busytone) {
1207 ixj_busytone(j);
1208 if (j->dsp.low == 0x20) {
1209 clear_bit(board, &j->busyflags);
1210 ixj_add_timer(j);
1211 return;
1212 }
1213 }
1214 if (j->flags.ringback) {
1215 ixj_ringback(j);
1216 if (j->dsp.low == 0x20) {
1217 clear_bit(board, &j->busyflags);
1218 ixj_add_timer(j);
1219 return;
1220 }
1221 }
1222 if (!j->tone_state) {
1223 ixj_cpt_stop(j);
1224 }
1225 }
1226 }
1227 if (!(j->tone_state && j->dsp.low == 0x20)) {
1228 if (IsRxReady(j)) {
1229 ixj_read_frame(j);
1230 }
1231 if (IsTxReady(j)) {
1232 ixj_write_frame(j);
1233 }
1234 }
1235 if (j->flags.cringing) {
1236 if (j->hookstate & 1) {
1237 j->flags.cringing = 0;
1238 ixj_ring_off(j);
1239 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240 switch(j->cadence_f[5].state) {
1241 case 0:
1242 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244 if(ixjdebug & 0x0004) {
1245 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246 }
1247 ixj_ring_on(j);
1248 }
1249 j->cadence_f[5].state = 1;
1250 break;
1251 case 1:
1252 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254 if(ixjdebug & 0x0004) {
1255 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256 }
1257 ixj_ring_off(j);
1258 j->cadence_f[5].state = 2;
1259 }
1260 break;
1261 case 2:
1262 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263 if(ixjdebug & 0x0004) {
1264 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265 }
1266 ixj_ring_on(j);
1267 if (j->cadence_f[5].on2) {
1268 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269 j->cadence_f[5].state = 3;
1270 } else {
1271 j->cadence_f[5].state = 7;
1272 }
1273 }
1274 break;
1275 case 3:
1276 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277 if(ixjdebug & 0x0004) {
1278 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279 }
1280 ixj_ring_off(j);
1281 if (j->cadence_f[5].off2) {
1282 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283 j->cadence_f[5].state = 4;
1284 } else {
1285 j->cadence_f[5].state = 7;
1286 }
1287 }
1288 break;
1289 case 4:
1290 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291 if(ixjdebug & 0x0004) {
1292 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293 }
1294 ixj_ring_on(j);
1295 if (j->cadence_f[5].on3) {
1296 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297 j->cadence_f[5].state = 5;
1298 } else {
1299 j->cadence_f[5].state = 7;
1300 }
1301 }
1302 break;
1303 case 5:
1304 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305 if(ixjdebug & 0x0004) {
1306 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307 }
1308 ixj_ring_off(j);
1309 if (j->cadence_f[5].off3) {
1310 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311 j->cadence_f[5].state = 6;
1312 } else {
1313 j->cadence_f[5].state = 7;
1314 }
1315 }
1316 break;
1317 case 6:
1318 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->cadence_f[5].state = 7;
1323 }
1324 break;
1325 case 7:
1326 if(ixjdebug & 0x0004) {
1327 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328 }
1329 j->flags.cidring = 1;
1330 j->cadence_f[5].state = 0;
1331 break;
1332 }
1333 if (j->flags.cidring && !j->flags.cidsent) {
1334 j->flags.cidsent = 1;
1335 if(j->fskdcnt) {
1336 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337 ixj_pre_cid(j);
1338 }
1339 j->flags.cidring = 0;
1340 }
1341 clear_bit(board, &j->busyflags);
1342 ixj_add_timer(j);
1343 return;
1344 } else {
1345 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346 if (j->flags.cidring && !j->flags.cidsent) {
1347 j->flags.cidsent = 1;
1348 if(j->fskdcnt) {
1349 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350 ixj_pre_cid(j);
1351 }
1352 j->flags.cidring = 0;
1353 }
1354 j->ring_cadence_t--;
1355 if (j->ring_cadence_t == -1)
1356 j->ring_cadence_t = 15;
1357 j->ring_cadence_jif = jiffies;
1358
1359 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361 j->flags.firstring = 1;
1362 else
1363 ixj_ring_on(j);
1364 } else {
1365 ixj_ring_off(j);
1366 if(!j->flags.cidsent)
1367 j->flags.cidring = 1;
1368 }
1369 }
1370 clear_bit(board, &j->busyflags);
1371 ixj_add_timer(j);
1372 return;
1373 }
1374 }
1375 if (!j->flags.ringing) {
1376 if (j->hookstate) { /* & 1) { */
1377 if (j->dsp.low != 0x20 &&
1378 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380 }
1381 LineMonitor(j);
1382 read_filters(j);
1383 ixj_WriteDSPCommand(0x511B, j);
1384 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385 if (!j->m_hook && (j->hookstate & 1)) {
1386 j->m_hook = j->ex.bits.hookstate = 1;
1387 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388 }
1389 } else {
1390 if (j->ex.bits.dtmf_ready) {
1391 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392 }
1393 if (j->m_hook) {
1394 j->m_hook = 0;
1395 j->ex.bits.hookstate = 1;
1396 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397 }
1398 }
1399 }
1400 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401 ixj_pstn_state(j);
1402 }
1403 if (j->ex.bytes) {
1404 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1405 }
1406 clear_bit(board, &j->busyflags);
1407 }
1408 ixj_add_timer(j);
1409 }
1410
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413 unsigned long jif;
1414
1415 jif = jiffies + ((60 * hertz) / 100);
1416 while (!IsStatusReady(j)) {
1417 ixj_perfmon(j->statuswait);
1418 if (time_after(jiffies, jif)) {
1419 ixj_perfmon(j->statuswaitfail);
1420 return -1;
1421 }
1422 }
1423 return 0;
1424 }
1425
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428 unsigned long jif;
1429
1430 jif = jiffies + ((60 * hertz) / 100);
1431 while (!IsPCControlReady(j)) {
1432 ixj_perfmon(j->pcontrolwait);
1433 if (time_after(jiffies, jif)) {
1434 ixj_perfmon(j->pcontrolwaitfail);
1435 return -1;
1436 }
1437 }
1438 return 0;
1439 }
1440
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443 BYTES bytes;
1444 unsigned long jif;
1445
1446 atomic_inc(&j->DSPWrite);
1447 if(atomic_read(&j->DSPWrite) > 1) {
1448 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449 return -1;
1450 }
1451 bytes.high = (cmd & 0xFF00) >> 8;
1452 bytes.low = cmd & 0x00FF;
1453 jif = jiffies + ((60 * hertz) / 100);
1454 while (!IsControlReady(j)) {
1455 ixj_perfmon(j->iscontrolready);
1456 if (time_after(jiffies, jif)) {
1457 ixj_perfmon(j->iscontrolreadyfail);
1458 atomic_dec(&j->DSPWrite);
1459 if(atomic_read(&j->DSPWrite) > 0) {
1460 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461 while(atomic_read(&j->DSPWrite) > 0) {
1462 atomic_dec(&j->DSPWrite);
1463 }
1464 }
1465 return -1;
1466 }
1467 }
1468 outb(bytes.low, j->DSPbase + 6);
1469 outb(bytes.high, j->DSPbase + 7);
1470
1471 if (ixj_status_wait(j)) {
1472 j->ssr.low = 0xFF;
1473 j->ssr.high = 0xFF;
1474 atomic_dec(&j->DSPWrite);
1475 if(atomic_read(&j->DSPWrite) > 0) {
1476 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477 while(atomic_read(&j->DSPWrite) > 0) {
1478 atomic_dec(&j->DSPWrite);
1479 }
1480 }
1481 return -1;
1482 }
1483 /* Read Software Status Register */
1484 j->ssr.low = inb_p(j->DSPbase + 2);
1485 j->ssr.high = inb_p(j->DSPbase + 3);
1486 atomic_dec(&j->DSPWrite);
1487 if(atomic_read(&j->DSPWrite) > 0) {
1488 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489 while(atomic_read(&j->DSPWrite) > 0) {
1490 atomic_dec(&j->DSPWrite);
1491 }
1492 }
1493 return 0;
1494 }
1495
1496 /***************************************************************************
1497 *
1498 * General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503 if (ixj_WriteDSPCommand(0x5143, j))
1504 return -1;
1505
1506 j->gpio.bytes.low = j->ssr.low;
1507 j->gpio.bytes.high = j->ssr.high;
1508
1509 return 0;
1510 }
1511
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514 if (j->cardtype == QTI_LINEJACK) {
1515 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520 outb(j->pld_scrw.byte, j->XILINXbase);
1521 }
1522 }
1523
1524 /*********************************************************************
1525 * GPIO Pins are configured as follows on the Quicknet Internet
1526 * PhoneJACK Telephony Cards
1527 *
1528 * POTS Select GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540 if (j->cardtype == QTI_PHONEJACK_LITE) {
1541 if (arg != PORT_POTS)
1542 return 10;
1543 else
1544 return 0;
1545 }
1546 switch (arg) {
1547 case PORT_POTS:
1548 j->port = PORT_POTS;
1549 switch (j->cardtype) {
1550 case QTI_PHONECARD:
1551 if (j->flags.pcmciasct == 1)
1552 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553 else
1554 return 11;
1555 break;
1556 case QTI_PHONEJACK_PCI:
1557 j->pld_slicw.pcib.mic = 0;
1558 j->pld_slicw.pcib.spk = 0;
1559 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560 break;
1561 case QTI_LINEJACK:
1562 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1563 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1564 Software Control Register */
1565 return 2;
1566 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1567
1568 outb(j->pld_scrw.byte, j->XILINXbase);
1569 j->pld_clock.byte = 0;
1570 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571 j->pld_slicw.bits.rly1 = 1;
1572 j->pld_slicw.bits.spken = 0;
1573 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1575 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1576 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1577 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1578 ixj_mixer(0x0E80, j); /*Mic mute */
1579 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1580 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1581 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1582 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584 break;
1585 case QTI_PHONEJACK:
1586 j->gpio.bytes.high = 0x0B;
1587 j->gpio.bits.gpio6 = 0;
1588 j->gpio.bits.gpio7 = 0;
1589 ixj_WriteDSPCommand(j->gpio.word, j);
1590 break;
1591 }
1592 break;
1593 case PORT_PSTN:
1594 if (j->cardtype == QTI_LINEJACK) {
1595 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597 j->pld_slicw.bits.rly3 = 0;
1598 j->pld_slicw.bits.rly1 = 1;
1599 j->pld_slicw.bits.spken = 0;
1600 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601 j->port = PORT_PSTN;
1602 } else {
1603 return 4;
1604 }
1605 break;
1606 case PORT_SPEAKER:
1607 j->port = PORT_SPEAKER;
1608 switch (j->cardtype) {
1609 case QTI_PHONECARD:
1610 if (j->flags.pcmciasct) {
1611 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612 }
1613 break;
1614 case QTI_PHONEJACK_PCI:
1615 j->pld_slicw.pcib.mic = 1;
1616 j->pld_slicw.pcib.spk = 1;
1617 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618 break;
1619 case QTI_LINEJACK:
1620 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1621 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1622 Software Control Register */
1623 return 2;
1624 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1625
1626 outb(j->pld_scrw.byte, j->XILINXbase);
1627 j->pld_clock.byte = 0;
1628 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629 j->pld_slicw.bits.rly1 = 1;
1630 j->pld_slicw.bits.spken = 1;
1631 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1633 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1634 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1635 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1636 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1637 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1638 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1639 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1640 break;
1641 case QTI_PHONEJACK:
1642 j->gpio.bytes.high = 0x0B;
1643 j->gpio.bits.gpio6 = 0;
1644 j->gpio.bits.gpio7 = 1;
1645 ixj_WriteDSPCommand(j->gpio.word, j);
1646 break;
1647 }
1648 break;
1649 case PORT_HANDSET:
1650 if (j->cardtype != QTI_PHONEJACK) {
1651 return 5;
1652 } else {
1653 j->gpio.bytes.high = 0x0B;
1654 j->gpio.bits.gpio6 = 1;
1655 j->gpio.bits.gpio7 = 0;
1656 ixj_WriteDSPCommand(j->gpio.word, j);
1657 j->port = PORT_HANDSET;
1658 }
1659 break;
1660 default:
1661 return 6;
1662 break;
1663 }
1664 return 0;
1665 }
1666
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669 if (j->cardtype == QTI_LINEJACK) {
1670 if (arg) {
1671 if (j->port == PORT_PSTN) {
1672 j->pld_slicw.bits.rly1 = 0;
1673 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674 j->flags.pots_pstn = 1;
1675 return 1;
1676 } else {
1677 j->flags.pots_pstn = 0;
1678 return 0;
1679 }
1680 } else {
1681 j->pld_slicw.bits.rly1 = 1;
1682 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683 j->flags.pots_pstn = 0;
1684 return 1;
1685 }
1686 } else {
1687 return 0;
1688 }
1689 }
1690
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694 {
1695 if (ixjdebug & 0x0004)
1696 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1697
1698 j->gpio.bytes.high = 0x0B;
1699 j->gpio.bytes.low = 0x00;
1700 j->gpio.bits.gpio1 = 1;
1701 j->gpio.bits.gpio2 = 1;
1702 j->gpio.bits.gpio5 = 0;
1703 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1704 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705 {
1706 if (ixjdebug & 0x0004)
1707 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710 }
1711 }
1712
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715 if(j->cardtype == QTI_PHONECARD){
1716 if(j->flags.pcmciascp){
1717 if(val == -1)
1718 return j->siadc.bits.rxg;
1719
1720 if(val < 0 || val > 0x1F)
1721 return -1;
1722
1723 j->siadc.bits.hom = 0; /* Handset Out Mute */
1724 j->siadc.bits.lom = 0; /* Line Out Mute */
1725 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1726 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1727 j->psccr.bits.rw = 0; /* Read / Write flag */
1728 j->psccr.bits.dev = 0;
1729 outb(j->siadc.byte, j->XILINXbase + 0x00);
1730 outb(j->psccr.byte, j->XILINXbase + 0x01);
1731 ixj_PCcontrol_wait(j);
1732 return j->siadc.bits.rxg;
1733 }
1734 }
1735 return -1;
1736 }
1737
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740 if(j->cardtype == QTI_PHONECARD){
1741 if(j->flags.pcmciascp){
1742 if(val == -1)
1743 return j->sidac.bits.txg;
1744
1745 if(val < 0 || val > 0x1F)
1746 return -1;
1747
1748 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1749 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1750 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1751 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1752 j->psccr.bits.rw = 0; /* Read / Write flag */
1753 j->psccr.bits.dev = 0;
1754 outb(j->sidac.byte, j->XILINXbase + 0x00);
1755 outb(j->psccr.byte, j->XILINXbase + 0x01);
1756 ixj_PCcontrol_wait(j);
1757 return j->sidac.bits.txg;
1758 }
1759 }
1760 return -1;
1761 }
1762
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766 if (!j->flags.pcmciastate) {
1767 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769 j->flags.pcmciastate = 4;
1770 return 0;
1771 }
1772 if (j->pccr1.bits.ed) {
1773 j->pccr1.bits.ed = 0;
1774 j->psccr.bits.dev = 3;
1775 j->psccr.bits.rw = 1;
1776 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777 ixj_PCcontrol_wait(j);
1778 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780 j->psccr.bits.dev = 3;
1781 j->psccr.bits.rw = 0;
1782 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783 ixj_PCcontrol_wait(j);
1784 return j->pslic.bits.led2 ? 1 : 0;
1785 } else if (j->flags.pcmciasct) {
1786 return j->r_hook;
1787 } else {
1788 return 1;
1789 }
1790 } else if (j->flags.pcmciastate == 4) {
1791 if (!j->pccr1.bits.drf) {
1792 j->flags.pcmciastate = 3;
1793 }
1794 return 0;
1795 } else if (j->flags.pcmciastate == 3) {
1796 j->pccr2.bits.pwr = 0;
1797 j->pccr2.bits.rstc = 1;
1798 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799 j->checkwait = jiffies + (hertz * 2);
1800 j->flags.incheck = 1;
1801 j->flags.pcmciastate = 2;
1802 return 0;
1803 } else if (j->flags.pcmciastate == 2) {
1804 if (j->flags.incheck) {
1805 if (time_before(jiffies, j->checkwait)) {
1806 return 0;
1807 } else {
1808 j->flags.incheck = 0;
1809 }
1810 }
1811 j->pccr2.bits.pwr = 0;
1812 j->pccr2.bits.rstc = 0;
1813 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814 j->flags.pcmciastate = 1;
1815 return 0;
1816 } else if (j->flags.pcmciastate == 1) {
1817 j->flags.pcmciastate = 0;
1818 if (!j->pccr1.bits.drf) {
1819 j->psccr.bits.dev = 3;
1820 j->psccr.bits.rw = 1;
1821 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822 ixj_PCcontrol_wait(j);
1823 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1824
1825 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1826
1827 if (j->flags.pcmciasct == 3) {
1828 j->flags.pcmciastate = 4;
1829 return 0;
1830 } else if (j->flags.pcmciasct == 0) {
1831 j->pccr2.bits.pwr = 1;
1832 j->pccr2.bits.rstc = 0;
1833 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834 j->port = PORT_SPEAKER;
1835 } else {
1836 j->port = PORT_POTS;
1837 }
1838 j->sic1.bits.cpd = 0; /* Chip Power Down */
1839 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1840 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1841 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1842 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1843 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1844 j->psccr.bits.rw = 0; /* Read / Write flag */
1845 j->psccr.bits.dev = 0;
1846 outb(j->sic1.byte, j->XILINXbase + 0x00);
1847 outb(j->psccr.byte, j->XILINXbase + 0x01);
1848 ixj_PCcontrol_wait(j);
1849
1850 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1851 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1852 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1853 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1854 j->sic2.bits.hpd = 0; /* HPF disable */
1855 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(j->sic2.byte, j->XILINXbase + 0x00);
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1870 j->psccr.bits.rw = 0; /* Read / Write flag */
1871 j->psccr.bits.dev = 0;
1872 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1873 outb(j->psccr.byte, j->XILINXbase + 0x01);
1874 ixj_PCcontrol_wait(j);
1875
1876 j->sirxg.bits.lig = 1; /* Line In Gain */
1877 j->sirxg.bits.lim = 1; /* Line In Mute */
1878 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1879 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1880 j->sirxg.bits.him = 0; /* Handset In Mute */
1881 j->sirxg.bits.iir = 1; /* IIR */
1882 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1883 j->psccr.bits.rw = 0; /* Read / Write flag */
1884 j->psccr.bits.dev = 0;
1885 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886 outb(j->psccr.byte, j->XILINXbase + 0x01);
1887 ixj_PCcontrol_wait(j);
1888
1889 ixj_siadc(j, 0x17);
1890 ixj_sidac(j, 0x1D);
1891
1892 j->siaatt.bits.sot = 0;
1893 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1894 j->psccr.bits.rw = 0; /* Read / Write flag */
1895 j->psccr.bits.dev = 0;
1896 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897 outb(j->psccr.byte, j->XILINXbase + 0x01);
1898 ixj_PCcontrol_wait(j);
1899
1900 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901 j->psccr.byte = j->pslic.byte = 0;
1902 j->pslic.bits.powerdown = 1;
1903 j->psccr.bits.dev = 3;
1904 j->psccr.bits.rw = 0;
1905 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906 ixj_PCcontrol_wait(j);
1907 }
1908 }
1909 return 0;
1910 } else {
1911 j->flags.pcmciascp = 0;
1912 return 0;
1913 }
1914 return 0;
1915 }
1916
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919 int fOffHook = 0;
1920
1921 switch (j->cardtype) {
1922 case QTI_PHONEJACK:
1923 ixj_gpio_read(j);
1924 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925 break;
1926 case QTI_LINEJACK:
1927 case QTI_PHONEJACK_LITE:
1928 case QTI_PHONEJACK_PCI:
1929 SLIC_GetState(j);
1930 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932 if(fOffHook != j->p_hook) {
1933 if(!j->checkwait) {
1934 j->checkwait = jiffies;
1935 }
1936 if(time_before(jiffies, j->checkwait + 2)) {
1937 fOffHook ^= 1;
1938 } else {
1939 j->checkwait = 0;
1940 }
1941 j->p_hook = fOffHook;
1942 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943 }
1944 } else {
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947 if (j->flags.ringing || j->flags.cringing) {
1948 if (!in_interrupt()) {
1949 msleep(20);
1950 }
1951 SLIC_GetState(j);
1952 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953 ixj_ring_on(j);
1954 }
1955 }
1956 if (j->cardtype == QTI_PHONEJACK_PCI) {
1957 j->pld_scrr.byte = inb_p(j->XILINXbase);
1958 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959 } else
1960 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961 }
1962 }
1963 break;
1964 case QTI_PHONECARD:
1965 fOffHook = ixj_pcmcia_cable_check(j);
1966 break;
1967 }
1968 if (j->r_hook != fOffHook) {
1969 j->r_hook = fOffHook;
1970 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971 j->ex.bits.hookstate = 1;
1972 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973 } else if (!fOffHook) {
1974 j->flash_end = jiffies + ((60 * hertz) / 100);
1975 }
1976 }
1977 if (fOffHook) {
1978 if(time_before(jiffies, j->flash_end)) {
1979 j->ex.bits.flash = 1;
1980 j->flash_end = 0;
1981 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982 }
1983 } else {
1984 if(time_before(jiffies, j->flash_end)) {
1985 fOffHook = 1;
1986 }
1987 }
1988
1989 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990 fOffHook |= 2;
1991
1992 if (j->port == PORT_SPEAKER) {
1993 if(j->cardtype == QTI_PHONECARD) {
1994 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995 fOffHook |= 2;
1996 }
1997 } else {
1998 fOffHook |= 2;
1999 }
2000 }
2001
2002 if (j->port == PORT_HANDSET)
2003 fOffHook |= 2;
2004
2005 return fOffHook;
2006 }
2007
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011 {
2012 if (ixjdebug & 0x0004)
2013 printk(KERN_INFO "IXJ Ring Off\n");
2014 j->gpio.bytes.high = 0x0B;
2015 j->gpio.bytes.low = 0x00;
2016 j->gpio.bits.gpio1 = 0;
2017 j->gpio.bits.gpio2 = 1;
2018 j->gpio.bits.gpio5 = 0;
2019 ixj_WriteDSPCommand(j->gpio.word, j);
2020 } else /* Internet LineJACK */
2021 {
2022 if (ixjdebug & 0x0004)
2023 printk(KERN_INFO "IXJ Ring Off\n");
2024
2025 if(!j->flags.cidplay)
2026 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028 SLIC_GetState(j);
2029 }
2030 }
2031
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034 j->flags.cringing = 1;
2035 if (ixjdebug & 0x0004)
2036 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037 if (ixj_hookstate(j) & 1) {
2038 if (j->port == PORT_POTS)
2039 ixj_ring_off(j);
2040 j->flags.cringing = 0;
2041 if (ixjdebug & 0x0004)
2042 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044 j->ring_cadence_jif = jiffies;
2045 j->flags.cidsent = j->flags.cidring = 0;
2046 j->cadence_f[5].state = 0;
2047 if(j->cadence_f[5].on1)
2048 ixj_ring_on(j);
2049 } else {
2050 j->ring_cadence_jif = jiffies;
2051 j->ring_cadence_t = 15;
2052 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053 ixj_ring_on(j);
2054 } else {
2055 ixj_ring_off(j);
2056 }
2057 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058 }
2059 }
2060
2061 static int ixj_ring(IXJ *j)
2062 {
2063 char cntr;
2064 unsigned long jif;
2065
2066 j->flags.ringing = 1;
2067 if (ixj_hookstate(j) & 1) {
2068 ixj_ring_off(j);
2069 j->flags.ringing = 0;
2070 return 1;
2071 }
2072 for (cntr = 0; cntr < j->maxrings; cntr++) {
2073 jif = jiffies + (1 * hertz);
2074 ixj_ring_on(j);
2075 while (time_before(jiffies, jif)) {
2076 if (ixj_hookstate(j) & 1) {
2077 ixj_ring_off(j);
2078 j->flags.ringing = 0;
2079 return 1;
2080 }
2081 schedule_timeout_interruptible(1);
2082 if (signal_pending(current))
2083 break;
2084 }
2085 jif = jiffies + (3 * hertz);
2086 ixj_ring_off(j);
2087 while (time_before(jiffies, jif)) {
2088 if (ixj_hookstate(j) & 1) {
2089 msleep(10);
2090 if (ixj_hookstate(j) & 1) {
2091 j->flags.ringing = 0;
2092 return 1;
2093 }
2094 }
2095 schedule_timeout_interruptible(1);
2096 if (signal_pending(current))
2097 break;
2098 }
2099 }
2100 ixj_ring_off(j);
2101 j->flags.ringing = 0;
2102 return 0;
2103 }
2104
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107 IXJ *j = get_ixj(p->board);
2108 file_p->private_data = j;
2109
2110 if (!j->DSPbase)
2111 return -ENODEV;
2112
2113 if (file_p->f_mode & FMODE_READ) {
2114 if(!j->readers) {
2115 j->readers++;
2116 } else {
2117 return -EBUSY;
2118 }
2119 }
2120
2121 if (file_p->f_mode & FMODE_WRITE) {
2122 if(!j->writers) {
2123 j->writers++;
2124 } else {
2125 if (file_p->f_mode & FMODE_READ){
2126 j->readers--;
2127 }
2128 return -EBUSY;
2129 }
2130 }
2131
2132 if (j->cardtype == QTI_PHONECARD) {
2133 j->pslic.bits.powerdown = 0;
2134 j->psccr.bits.dev = 3;
2135 j->psccr.bits.rw = 0;
2136 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137 ixj_PCcontrol_wait(j);
2138 }
2139
2140 j->flags.cidplay = 0;
2141 j->flags.cidcw_ack = 0;
2142
2143 if (ixjdebug & 0x0002)
2144 printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146 j->framesread = j->frameswritten = 0;
2147 return 0;
2148 }
2149
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152 IXJ_TONE ti;
2153 int cnt;
2154 IXJ *j = file_p->private_data;
2155 int board = j->p.board;
2156
2157 /*
2158 * Set up locks to ensure that only one process is talking to the DSP at a time.
2159 * This is necessary to keep the DSP from locking up.
2160 */
2161 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162 schedule_timeout_interruptible(1);
2163 if (ixjdebug & 0x0002)
2164 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166 if (j->cardtype == QTI_PHONECARD)
2167 ixj_set_port(j, PORT_SPEAKER);
2168 else
2169 ixj_set_port(j, PORT_POTS);
2170
2171 aec_stop(j);
2172 ixj_play_stop(j);
2173 ixj_record_stop(j);
2174 set_play_volume(j, 0x100);
2175 set_rec_volume(j, 0x100);
2176 ixj_ring_off(j);
2177
2178 /* Restore the tone table to default settings. */
2179 ti.tone_index = 10;
2180 ti.gain0 = 1;
2181 ti.freq0 = hz941;
2182 ti.gain1 = 0;
2183 ti.freq1 = hz1209;
2184 ixj_init_tone(j, &ti);
2185 ti.tone_index = 11;
2186 ti.gain0 = 1;
2187 ti.freq0 = hz941;
2188 ti.gain1 = 0;
2189 ti.freq1 = hz1336;
2190 ixj_init_tone(j, &ti);
2191 ti.tone_index = 12;
2192 ti.gain0 = 1;
2193 ti.freq0 = hz941;
2194 ti.gain1 = 0;
2195 ti.freq1 = hz1477;
2196 ixj_init_tone(j, &ti);
2197 ti.tone_index = 13;
2198 ti.gain0 = 1;
2199 ti.freq0 = hz800;
2200 ti.gain1 = 0;
2201 ti.freq1 = 0;
2202 ixj_init_tone(j, &ti);
2203 ti.tone_index = 14;
2204 ti.gain0 = 1;
2205 ti.freq0 = hz1000;
2206 ti.gain1 = 0;
2207 ti.freq1 = 0;
2208 ixj_init_tone(j, &ti);
2209 ti.tone_index = 15;
2210 ti.gain0 = 1;
2211 ti.freq0 = hz1250;
2212 ti.gain1 = 0;
2213 ti.freq1 = 0;
2214 ixj_init_tone(j, &ti);
2215 ti.tone_index = 16;
2216 ti.gain0 = 1;
2217 ti.freq0 = hz950;
2218 ti.gain1 = 0;
2219 ti.freq1 = 0;
2220 ixj_init_tone(j, &ti);
2221 ti.tone_index = 17;
2222 ti.gain0 = 1;
2223 ti.freq0 = hz1100;
2224 ti.gain1 = 0;
2225 ti.freq1 = 0;
2226 ixj_init_tone(j, &ti);
2227 ti.tone_index = 18;
2228 ti.gain0 = 1;
2229 ti.freq0 = hz1400;
2230 ti.gain1 = 0;
2231 ti.freq1 = 0;
2232 ixj_init_tone(j, &ti);
2233 ti.tone_index = 19;
2234 ti.gain0 = 1;
2235 ti.freq0 = hz1500;
2236 ti.gain1 = 0;
2237 ti.freq1 = 0;
2238 ixj_init_tone(j, &ti);
2239 ti.tone_index = 20;
2240 ti.gain0 = 1;
2241 ti.freq0 = hz1600;
2242 ti.gain1 = 0;
2243 ti.freq1 = 0;
2244 ixj_init_tone(j, &ti);
2245 ti.tone_index = 21;
2246 ti.gain0 = 1;
2247 ti.freq0 = hz1800;
2248 ti.gain1 = 0;
2249 ti.freq1 = 0;
2250 ixj_init_tone(j, &ti);
2251 ti.tone_index = 22;
2252 ti.gain0 = 1;
2253 ti.freq0 = hz2100;
2254 ti.gain1 = 0;
2255 ti.freq1 = 0;
2256 ixj_init_tone(j, &ti);
2257 ti.tone_index = 23;
2258 ti.gain0 = 1;
2259 ti.freq0 = hz1300;
2260 ti.gain1 = 0;
2261 ti.freq1 = 0;
2262 ixj_init_tone(j, &ti);
2263 ti.tone_index = 24;
2264 ti.gain0 = 1;
2265 ti.freq0 = hz2450;
2266 ti.gain1 = 0;
2267 ti.freq1 = 0;
2268 ixj_init_tone(j, &ti);
2269 ti.tone_index = 25;
2270 ti.gain0 = 1;
2271 ti.freq0 = hz350;
2272 ti.gain1 = 0;
2273 ti.freq1 = hz440;
2274 ixj_init_tone(j, &ti);
2275 ti.tone_index = 26;
2276 ti.gain0 = 1;
2277 ti.freq0 = hz440;
2278 ti.gain1 = 0;
2279 ti.freq1 = hz480;
2280 ixj_init_tone(j, &ti);
2281 ti.tone_index = 27;
2282 ti.gain0 = 1;
2283 ti.freq0 = hz480;
2284 ti.gain1 = 0;
2285 ti.freq1 = hz620;
2286 ixj_init_tone(j, &ti);
2287
2288 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2289
2290 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2291
2292 j->ex.bits.dtmf_ready = 0;
2293 j->dtmf_state = 0;
2294 j->dtmf_wp = j->dtmf_rp = 0;
2295 j->rec_mode = j->play_mode = -1;
2296 j->flags.ringing = 0;
2297 j->maxrings = MAXRINGS;
2298 j->ring_cadence = USA_RING_CADENCE;
2299 if(j->cadence_f[5].enable) {
2300 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301 }
2302 j->drybuffer = 0;
2303 j->winktime = 320;
2304 j->flags.dtmf_oob = 0;
2305 for (cnt = 0; cnt < 4; cnt++)
2306 j->cadence_f[cnt].enable = 0;
2307
2308 idle(j);
2309
2310 if(j->cardtype == QTI_PHONECARD) {
2311 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312 }
2313
2314 if (file_p->f_mode & FMODE_READ)
2315 j->readers--;
2316 if (file_p->f_mode & FMODE_WRITE)
2317 j->writers--;
2318
2319 if (j->read_buffer && !j->readers) {
2320 kfree(j->read_buffer);
2321 j->read_buffer = NULL;
2322 j->read_buffer_size = 0;
2323 }
2324 if (j->write_buffer && !j->writers) {
2325 kfree(j->write_buffer);
2326 j->write_buffer = NULL;
2327 j->write_buffer_size = 0;
2328 }
2329 j->rec_codec = j->play_codec = 0;
2330 j->rec_frame_size = j->play_frame_size = 0;
2331 j->flags.cidsent = j->flags.cidring = 0;
2332
2333 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334 ixj_set_port(j, PORT_PSTN);
2335 daa_set_mode(j, SOP_PU_SLEEP);
2336 ixj_set_pots(j, 1);
2337 }
2338 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340 /* Set up the default signals for events */
2341 for (cnt = 0; cnt < 35; cnt++)
2342 j->ixj_signals[cnt] = SIGIO;
2343
2344 /* Set the excetion signal enable flags */
2345 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346 j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347 j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349 file_p->private_data = NULL;
2350 clear_bit(board, &j->busyflags);
2351 return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356 unsigned short fc, cnt, trg;
2357 int var;
2358
2359 trg = 0;
2360 if (ixj_WriteDSPCommand(0x5144, j)) {
2361 if(ixjdebug & 0x0001) {
2362 printk(KERN_INFO "Read Frame Counter failed!\n");
2363 }
2364 return -1;
2365 }
2366 fc = j->ssr.high << 8 | j->ssr.low;
2367 if (fc == j->frame_count)
2368 return 1;
2369
2370 j->frame_count = fc;
2371
2372 if (j->dtmf_proc)
2373 return 1;
2374
2375 var = 10;
2376
2377 for (cnt = 0; cnt < 4; cnt++) {
2378 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379 if(ixjdebug & 0x0001) {
2380 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381 }
2382 return -1;
2383 }
2384 if (ixj_WriteDSPCommand(0x515C, j)) {
2385 if(ixjdebug & 0x0001) {
2386 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387 }
2388 return -1;
2389 }
2390 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392 if (j->cadence_f[cnt].enable) {
2393 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394 if (j->cadence_f[cnt].state == 0) {
2395 j->cadence_f[cnt].state = 1;
2396 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399 } else if (j->cadence_f[cnt].state == 2 &&
2400 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402 if (j->cadence_f[cnt].on2) {
2403 j->cadence_f[cnt].state = 3;
2404 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407 } else {
2408 j->cadence_f[cnt].state = 7;
2409 }
2410 } else if (j->cadence_f[cnt].state == 4 &&
2411 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413 if (j->cadence_f[cnt].on3) {
2414 j->cadence_f[cnt].state = 5;
2415 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418 } else {
2419 j->cadence_f[cnt].state = 7;
2420 }
2421 } else {
2422 j->cadence_f[cnt].state = 0;
2423 }
2424 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425 if (j->cadence_f[cnt].state == 1) {
2426 if(!j->cadence_f[cnt].on1) {
2427 j->cadence_f[cnt].state = 7;
2428 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430 if(j->cadence_f[cnt].off1) {
2431 j->cadence_f[cnt].state = 2;
2432 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435 } else {
2436 j->cadence_f[cnt].state = 7;
2437 }
2438 } else {
2439 j->cadence_f[cnt].state = 0;
2440 }
2441 } else if (j->cadence_f[cnt].state == 3) {
2442 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444 if(j->cadence_f[cnt].off2) {
2445 j->cadence_f[cnt].state = 4;
2446 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449 } else {
2450 j->cadence_f[cnt].state = 7;
2451 }
2452 } else {
2453 j->cadence_f[cnt].state = 0;
2454 }
2455 } else if (j->cadence_f[cnt].state == 5) {
2456 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458 if(j->cadence_f[cnt].off3) {
2459 j->cadence_f[cnt].state = 6;
2460 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463 } else {
2464 j->cadence_f[cnt].state = 7;
2465 }
2466 } else {
2467 j->cadence_f[cnt].state = 0;
2468 }
2469 } else {
2470 j->cadence_f[cnt].state = 0;
2471 }
2472 } else {
2473 switch(j->cadence_f[cnt].state) {
2474 case 1:
2475 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476 !j->cadence_f[cnt].off1 &&
2477 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479 j->cadence_f[cnt].state = 7;
2480 }
2481 break;
2482 case 3:
2483 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484 !j->cadence_f[cnt].off2 &&
2485 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486 j->cadence_f[cnt].state = 7;
2487 }
2488 break;
2489 case 5:
2490 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491 !j->cadence_f[cnt].off3) {
2492 j->cadence_f[cnt].state = 7;
2493 }
2494 break;
2495 }
2496 }
2497
2498 if (ixjdebug & 0x0040) {
2499 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500 switch(j->cadence_f[cnt].state) {
2501 case 0:
2502 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503 break;
2504 case 1:
2505 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507 break;
2508 case 2:
2509 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510 j->cadence_f[cnt].off1max);
2511 break;
2512 case 3:
2513 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514 j->cadence_f[cnt].on2max);
2515 break;
2516 case 4:
2517 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518 j->cadence_f[cnt].off2max);
2519 break;
2520 case 5:
2521 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522 j->cadence_f[cnt].on3max);
2523 break;
2524 case 6:
2525 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526 j->cadence_f[cnt].off3max);
2527 break;
2528 }
2529 }
2530 }
2531 if (j->cadence_f[cnt].state == 7) {
2532 j->cadence_f[cnt].state = 0;
2533 if (j->cadence_f[cnt].enable == 1)
2534 j->cadence_f[cnt].enable = 0;
2535 switch (cnt) {
2536 case 0:
2537 if(ixjdebug & 0x0020) {
2538 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539 }
2540 j->ex.bits.fc0 = 1;
2541 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542 break;
2543 case 1:
2544 if(ixjdebug & 0x0020) {
2545 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546 }
2547 j->ex.bits.fc1 = 1;
2548 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549 break;
2550 case 2:
2551 if(ixjdebug & 0x0020) {
2552 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553 }
2554 j->ex.bits.fc2 = 1;
2555 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556 break;
2557 case 3:
2558 if(ixjdebug & 0x0020) {
2559 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560 }
2561 j->ex.bits.fc3 = 1;
2562 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563 break;
2564 }
2565 }
2566 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569 trg = 1;
2570 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571 trg = 0;
2572 }
2573 switch (cnt) {
2574 case 0:
2575 if(ixjdebug & 0x0020) {
2576 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577 }
2578 j->ex.bits.f0 = 1;
2579 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580 break;
2581 case 1:
2582 if(ixjdebug & 0x0020) {
2583 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584 }
2585 j->ex.bits.f1 = 1;
2586 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587 break;
2588 case 2:
2589 if(ixjdebug & 0x0020) {
2590 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591 }
2592 j->ex.bits.f2 = 1;
2593 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594 break;
2595 case 3:
2596 if(ixjdebug & 0x0020) {
2597 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598 }
2599 j->ex.bits.f3 = 1;
2600 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601 break;
2602 }
2603 }
2604 }
2605 return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610 if (j->dtmf_proc) {
2611 return -1;
2612 }
2613 j->dtmf_proc = 1;
2614
2615 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2616 return -1;
2617
2618 j->dtmf.bytes.high = j->ssr.high;
2619 j->dtmf.bytes.low = j->ssr.low;
2620 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621 j->dtmf_state = 1;
2622 j->dtmf_current = j->dtmf.bits.digit;
2623 }
2624 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2625 {
2626 if(!j->cidcw_wait) {
2627 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628 j->dtmf_wp++;
2629 if (j->dtmf_wp == 79)
2630 j->dtmf_wp = 0;
2631 j->ex.bits.dtmf_ready = 1;
2632 if(j->ex_sig.bits.dtmf_ready) {
2633 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634 }
2635 }
2636 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637 if(ixjdebug & 0x0020) {
2638 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639 }
2640 j->flags.cidcw_ack = 1;
2641 }
2642 j->dtmf_state = 0;
2643 }
2644 j->dtmf_proc = 0;
2645
2646 return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657 static unsigned char table_ulaw2alaw[] =
2658 {
2659 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691 };
2692
2693 while (len--)
2694 {
2695 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696 buff++;
2697 }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702 static unsigned char table_alaw2ulaw[] =
2703 {
2704 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736 };
2737
2738 while (len--)
2739 {
2740 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741 buff++;
2742 }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747 unsigned long i = *ppos;
2748 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750 DECLARE_WAITQUEUE(wait, current);
2751
2752 if (j->flags.inread)
2753 return -EALREADY;
2754
2755 j->flags.inread = 1;
2756
2757 add_wait_queue(&j->read_q, &wait);
2758 set_current_state(TASK_INTERRUPTIBLE);
2759 mb();
2760
2761 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762 ++j->read_wait;
2763 if (file_p->f_flags & O_NONBLOCK) {
2764 set_current_state(TASK_RUNNING);
2765 remove_wait_queue(&j->read_q, &wait);
2766 j->flags.inread = 0;
2767 return -EAGAIN;
2768 }
2769 if (!ixj_hookstate(j)) {
2770 set_current_state(TASK_RUNNING);
2771 remove_wait_queue(&j->read_q, &wait);
2772 j->flags.inread = 0;
2773 return 0;
2774 }
2775 interruptible_sleep_on(&j->read_q);
2776 if (signal_pending(current)) {
2777 set_current_state(TASK_RUNNING);
2778 remove_wait_queue(&j->read_q, &wait);
2779 j->flags.inread = 0;
2780 return -EINTR;
2781 }
2782 }
2783
2784 remove_wait_queue(&j->read_q, &wait);
2785 set_current_state(TASK_RUNNING);
2786 /* Don't ever copy more than the user asks */
2787 if(j->rec_codec == ALAW)
2788 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790 j->read_buffer_ready = 0;
2791 if (i) {
2792 j->flags.inread = 0;
2793 return -EFAULT;
2794 } else {
2795 j->flags.inread = 0;
2796 return min(length, j->read_buffer_size);
2797 }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801 loff_t * ppos)
2802 {
2803 int pre_retval;
2804 ssize_t read_retval = 0;
2805 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807 pre_retval = ixj_PreRead(j, 0L);
2808 switch (pre_retval) {
2809 case NORMAL:
2810 read_retval = ixj_read(file_p, buf, length, ppos);
2811 ixj_PostRead(j, 0L);
2812 break;
2813 case NOPOST:
2814 read_retval = ixj_read(file_p, buf, length, ppos);
2815 break;
2816 case POSTONLY:
2817 ixj_PostRead(j, 0L);
2818 break;
2819 default:
2820 read_retval = pre_retval;
2821 }
2822 return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827 unsigned long i = *ppos;
2828 IXJ *j = file_p->private_data;
2829
2830 DECLARE_WAITQUEUE(wait, current);
2831
2832 if (j->flags.inwrite)
2833 return -EALREADY;
2834
2835 j->flags.inwrite = 1;
2836
2837 add_wait_queue(&j->write_q, &wait);
2838 set_current_state(TASK_INTERRUPTIBLE);
2839 mb();
2840
2841
2842 while (!j->write_buffers_empty) {
2843 ++j->write_wait;
2844 if (file_p->f_flags & O_NONBLOCK) {
2845 set_current_state(TASK_RUNNING);
2846 remove_wait_queue(&j->write_q, &wait);
2847 j->flags.inwrite = 0;
2848 return -EAGAIN;
2849 }
2850 if (!ixj_hookstate(j)) {
2851 set_current_state(TASK_RUNNING);
2852 remove_wait_queue(&j->write_q, &wait);
2853 j->flags.inwrite = 0;
2854 return 0;
2855 }
2856 interruptible_sleep_on(&j->write_q);
2857 if (signal_pending(current)) {
2858 set_current_state(TASK_RUNNING);
2859 remove_wait_queue(&j->write_q, &wait);
2860 j->flags.inwrite = 0;
2861 return -EINTR;
2862 }
2863 }
2864 set_current_state(TASK_RUNNING);
2865 remove_wait_queue(&j->write_q, &wait);
2866 if (j->write_buffer_wp + count >= j->write_buffer_end)
2867 j->write_buffer_wp = j->write_buffer;
2868 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869 if (i) {
2870 j->flags.inwrite = 0;
2871 return -EFAULT;
2872 }
2873 if(j->play_codec == ALAW)
2874 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875 j->flags.inwrite = 0;
2876 return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881 int pre_retval;
2882 ssize_t write_retval = 0;
2883
2884 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886 pre_retval = ixj_PreWrite(j, 0L);
2887 switch (pre_retval) {
2888 case NORMAL:
2889 write_retval = ixj_write(file_p, buf, count, ppos);
2890 if (write_retval > 0) {
2891 ixj_PostWrite(j, 0L);
2892 j->write_buffer_wp += write_retval;
2893 j->write_buffers_empty--;
2894 }
2895 break;
2896 case NOPOST:
2897 write_retval = ixj_write(file_p, buf, count, ppos);
2898 if (write_retval > 0) {
2899 j->write_buffer_wp += write_retval;
2900 j->write_buffers_empty--;
2901 }
2902 break;
2903 case POSTONLY:
2904 ixj_PostWrite(j, 0L);
2905 break;
2906 default:
2907 write_retval = pre_retval;
2908 }
2909 return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914 int cnt, dly;
2915
2916 if (j->read_buffer) {
2917 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918 if (!(cnt % 16) && !IsRxReady(j)) {
2919 dly = 0;
2920 while (!IsRxReady(j)) {
2921 if (dly++ > 5) {
2922 dly = 0;
2923 break;
2924 }
2925 udelay(10);
2926 }
2927 }
2928 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930 inb_p(j->DSPbase + 0x0E);
2931 inb_p(j->DSPbase + 0x0F);
2932 }
2933 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935 }
2936 ++j->framesread;
2937 if (j->intercom != -1) {
2938 if (IsTxReady(get_ixj(j->intercom))) {
2939 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940 if (!(cnt % 16) && !IsTxReady(j)) {
2941 dly = 0;
2942 while (!IsTxReady(j)) {
2943 if (dly++ > 5) {
2944 dly = 0;
2945 break;
2946 }
2947 udelay(10);
2948 }
2949 }
2950 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952 }
2953 get_ixj(j->intercom)->frameswritten++;
2954 }
2955 } else {
2956 j->read_buffer_ready = 1;
2957 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2958
2959 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2960
2961 if(j->ixj_signals[SIG_READ_READY])
2962 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963 }
2964 }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969 {
2970 {
2971 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973 },
2974 {
2975 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977 },
2978 {
2979 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981 },
2982 {
2983 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985 },
2986 {
2987 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989 },
2990 {
2991 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993 }
2994 },
2995 {
2996 {
2997 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999 },
3000 {
3001 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003 },
3004 {
3005 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007 },
3008 {
3009 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011 },
3012 {
3013 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015 },
3016 {
3017 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019 }
3020 }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026 while (j->fskcnt < 20) {
3027 if(j->fskdcnt < (j->fsksize - 1))
3028 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030 j->fskcnt += 3;
3031 }
3032 j->fskcnt %= 20;
3033
3034 if (!bit)
3035 j->fskz++;
3036 if (j->fskz >= 6)
3037 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043 IXJ_CBYTE cb;
3044
3045 cb.cbyte = byte;
3046 ixj_write_cid_bit(j, 0);
3047 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060 int cnt;
3061
3062 for (cnt = 0; cnt < 150; cnt++) {
3063 ixj_write_cid_bit(j, 0);
3064 ixj_write_cid_bit(j, 1);
3065 }
3066 for (cnt = 0; cnt < 180; cnt++) {
3067 ixj_write_cid_bit(j, 1);
3068 }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073 int cnt;
3074
3075 for (cnt = 0; cnt < 80; cnt++) {
3076 ixj_write_cid_bit(j, 1);
3077 }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082 int cnt;
3083
3084 for (cnt = 0; cnt < strlen(s); cnt++) {
3085 ixj_write_cid_byte(j, s[cnt]);
3086 checksum = (checksum + s[cnt]);
3087 }
3088 return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093 int cnt;
3094
3095 for (cnt = 0; cnt < pad; cnt++) {
3096 if(j->fskdcnt < (j->fsksize - 1))
3097 j->fskdata[j->fskdcnt++] = 0x0000;
3098 }
3099 for (cnt = 0; cnt < 720; cnt++) {
3100 if(j->fskdcnt < (j->fsksize - 1))
3101 j->fskdata[j->fskdcnt++] = 0x0000;
3102 }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107 j->cid_play_codec = j->play_codec;
3108 j->cid_play_frame_size = j->play_frame_size;
3109 j->cid_play_volume = get_play_volume(j);
3110 j->cid_play_flag = j->flags.playing;
3111
3112 j->cid_rec_codec = j->rec_codec;
3113 j->cid_rec_volume = get_rec_volume(j);
3114 j->cid_rec_flag = j->flags.recording;
3115
3116 j->cid_play_aec_level = j->aec_level;
3117
3118 switch(j->baseframe.low) {
3119 case 0xA0:
3120 j->cid_base_frame_size = 20;
3121 break;
3122 case 0x50:
3123 j->cid_base_frame_size = 10;
3124 break;
3125 case 0xF0:
3126 j->cid_base_frame_size = 30;
3127 break;
3128 }
3129
3130 ixj_play_stop(j);
3131 ixj_cpt_stop(j);
3132
3133 j->flags.cidplay = 1;
3134
3135 set_base_frame(j, 30);
3136 set_play_codec(j, LINEAR16);
3137 set_play_volume(j, 0x1B);
3138 ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143 ixj_play_stop(j);
3144
3145 if(j->cidsize > 5000) {
3146 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147 }
3148 j->flags.cidplay = 0;
3149 if(ixjdebug & 0x0200) {
3150 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151 }
3152
3153 ixj_fsk_free(j);
3154
3155 j->fskdcnt = 0;
3156 set_base_frame(j, j->cid_base_frame_size);
3157 set_play_codec(j, j->cid_play_codec);
3158 ixj_aec_start(j, j->cid_play_aec_level);
3159 set_play_volume(j, j->cid_play_volume);
3160
3161 set_rec_codec(j, j->cid_rec_codec);
3162 set_rec_volume(j, j->cid_rec_volume);
3163
3164 if(j->cid_rec_flag)
3165 ixj_record_start(j);
3166
3167 if(j->cid_play_flag)
3168 ixj_play_start(j);
3169
3170 if(j->cid_play_flag) {
3171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3172 }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177 char sdmf1[50];
3178 char sdmf2[50];
3179 char sdmf3[80];
3180 char mdmflen, len1, len2, len3;
3181 int pad;
3182
3183 int checksum = 0;
3184
3185 if (j->dsp.low == 0x20 || j->flags.cidplay)
3186 return;
3187
3188 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189 j->cidsize = j->cidcnt = 0;
3190
3191 ixj_fsk_alloc(j);
3192
3193 strcpy(sdmf1, j->cid_send.month);
3194 strcat(sdmf1, j->cid_send.day);
3195 strcat(sdmf1, j->cid_send.hour);
3196 strcat(sdmf1, j->cid_send.min);
3197 strcpy(sdmf2, j->cid_send.number);
3198 strcpy(sdmf3, j->cid_send.name);
3199
3200 len1 = strlen(sdmf1);
3201 len2 = strlen(sdmf2);
3202 len3 = strlen(sdmf3);
3203 mdmflen = len1 + len2 + len3 + 6;
3204
3205 while(1){
3206 ixj_write_cid_seize(j);
3207
3208 ixj_write_cid_byte(j, 0x80);
3209 checksum = 0x80;
3210 ixj_write_cid_byte(j, mdmflen);
3211 checksum = checksum + mdmflen;
3212
3213 ixj_write_cid_byte(j, 0x01);
3214 checksum = checksum + 0x01;
3215 ixj_write_cid_byte(j, len1);
3216 checksum = checksum + len1;
3217 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218 if(ixj_hookstate(j) & 1)
3219 break;
3220
3221 ixj_write_cid_byte(j, 0x02);
3222 checksum = checksum + 0x02;
3223 ixj_write_cid_byte(j, len2);
3224 checksum = checksum + len2;
3225 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226 if(ixj_hookstate(j) & 1)
3227 break;
3228
3229 ixj_write_cid_byte(j, 0x07);
3230 checksum = checksum + 0x07;
3231 ixj_write_cid_byte(j, len3);
3232 checksum = checksum + len3;
3233 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234 if(ixj_hookstate(j) & 1)
3235 break;
3236
3237 checksum %= 256;
3238 checksum ^= 0xFF;
3239 checksum += 1;
3240
3241 ixj_write_cid_byte(j, (char) checksum);
3242
3243 pad = j->fskdcnt % 240;
3244 if (pad) {
3245 pad = 240 - pad;
3246 }
3247 ixj_pad_fsk(j, pad);
3248 break;
3249 }
3250
3251 ixj_write_frame(j);
3252 }
3253
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256 IXJ_TONE ti;
3257
3258 char sdmf1[50];
3259 char sdmf2[50];
3260 char sdmf3[80];
3261 char mdmflen, len1, len2, len3;
3262 int pad;
3263
3264 int checksum = 0;
3265
3266 if (j->dsp.low == 0x20 || j->flags.cidplay)
3267 return;
3268
3269 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270 j->cidsize = j->cidcnt = 0;
3271
3272 ixj_fsk_alloc(j);
3273
3274 j->flags.cidcw_ack = 0;
3275
3276 ti.tone_index = 23;
3277 ti.gain0 = 1;
3278 ti.freq0 = hz440;
3279 ti.gain1 = 0;
3280 ti.freq1 = 0;
3281 ixj_init_tone(j, &ti);
3282
3283 ixj_set_tone_on(1500, j);
3284 ixj_set_tone_off(32, j);
3285 if(ixjdebug & 0x0200) {
3286 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287 }
3288 ixj_play_tone(j, 23);
3289
3290 clear_bit(j->board, &j->busyflags);
3291 while(j->tone_state)
3292 schedule_timeout_interruptible(1);
3293 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294 schedule_timeout_interruptible(1);
3295 if(ixjdebug & 0x0200) {
3296 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297 }
3298
3299 ti.tone_index = 24;
3300 ti.gain0 = 1;
3301 ti.freq0 = hz2130;
3302 ti.gain1 = 0;
3303 ti.freq1 = hz2750;
3304 ixj_init_tone(j, &ti);
3305
3306 ixj_set_tone_off(10, j);
3307 ixj_set_tone_on(600, j);
3308 if(ixjdebug & 0x0200) {
3309 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310 }
3311 ixj_play_tone(j, 24);
3312
3313 clear_bit(j->board, &j->busyflags);
3314 while(j->tone_state)
3315 schedule_timeout_interruptible(1);
3316 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317 schedule_timeout_interruptible(1);
3318 if(ixjdebug & 0x0200) {
3319 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320 }
3321
3322 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324 clear_bit(j->board, &j->busyflags);
3325 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326 schedule_timeout_interruptible(1);
3327 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328 schedule_timeout_interruptible(1);
3329 j->cidcw_wait = 0;
3330 if(!j->flags.cidcw_ack) {
3331 if(ixjdebug & 0x0200) {
3332 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333 }
3334 ixj_post_cid(j);
3335 if(j->cid_play_flag) {
3336 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3337 }
3338 return;
3339 } else {
3340 ixj_pre_cid(j);
3341 }
3342 j->flags.cidcw_ack = 0;
3343 strcpy(sdmf1, j->cid_send.month);
3344 strcat(sdmf1, j->cid_send.day);
3345 strcat(sdmf1, j->cid_send.hour);
3346 strcat(sdmf1, j->cid_send.min);
3347 strcpy(sdmf2, j->cid_send.number);
3348 strcpy(sdmf3, j->cid_send.name);
3349
3350 len1 = strlen(sdmf1);
3351 len2 = strlen(sdmf2);
3352 len3 = strlen(sdmf3);
3353 mdmflen = len1 + len2 + len3 + 6;
3354
3355 ixj_write_cidcw_seize(j);
3356
3357 ixj_write_cid_byte(j, 0x80);
3358 checksum = 0x80;
3359 ixj_write_cid_byte(j, mdmflen);
3360 checksum = checksum + mdmflen;
3361
3362 ixj_write_cid_byte(j, 0x01);
3363 checksum = checksum + 0x01;
3364 ixj_write_cid_byte(j, len1);
3365 checksum = checksum + len1;
3366 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368 ixj_write_cid_byte(j, 0x02);
3369 checksum = checksum + 0x02;
3370 ixj_write_cid_byte(j, len2);
3371 checksum = checksum + len2;
3372 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374 ixj_write_cid_byte(j, 0x07);
3375 checksum = checksum + 0x07;
3376 ixj_write_cid_byte(j, len3);
3377 checksum = checksum + len3;
3378 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380 checksum %= 256;
3381 checksum ^= 0xFF;
3382 checksum += 1;
3383
3384 ixj_write_cid_byte(j, (char) checksum);
3385
3386 pad = j->fskdcnt % 240;
3387 if (pad) {
3388 pad = 240 - pad;
3389 }
3390 ixj_pad_fsk(j, pad);
3391 if(ixjdebug & 0x0200) {
3392 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393 }
3394 }
3395
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398 char mdmflen;
3399 int pad;
3400
3401 int checksum = 0;
3402
3403 if (j->dsp.low == 0x20 || j->flags.cidplay)
3404 return;
3405
3406 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407 j->cidsize = j->cidcnt = 0;
3408
3409 ixj_fsk_alloc(j);
3410
3411 mdmflen = 3;
3412
3413 if (j->port == PORT_POTS)
3414 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416 ixj_write_cid_seize(j);
3417
3418 ixj_write_cid_byte(j, 0x82);
3419 checksum = 0x82;
3420 ixj_write_cid_byte(j, mdmflen);
3421 checksum = checksum + mdmflen;
3422
3423 ixj_write_cid_byte(j, 0x0B);
3424 checksum = checksum + 0x0B;
3425 ixj_write_cid_byte(j, 1);
3426 checksum = checksum + 1;
3427
3428 if(msg) {
3429 ixj_write_cid_byte(j, 0xFF);
3430 checksum = checksum + 0xFF;
3431 }
3432 else {
3433 ixj_write_cid_byte(j, 0x00);
3434 checksum = checksum + 0x00;
3435 }
3436
3437 checksum %= 256;
3438 checksum ^= 0xFF;
3439 checksum += 1;
3440
3441 ixj_write_cid_byte(j, (char) checksum);
3442
3443 pad = j->fskdcnt % 240;
3444 if (pad) {
3445 pad = 240 - pad;
3446 }
3447 ixj_pad_fsk(j, pad);
3448 }
3449
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452 int cnt, frame_count, dly;
3453 IXJ_WORD dat;
3454
3455 frame_count = 0;
3456 if(j->flags.cidplay) {
3457 for(cnt = 0; cnt < 480; cnt++) {
3458 if (!(cnt % 16) && !IsTxReady(j)) {
3459 dly = 0;
3460 while (!IsTxReady(j)) {
3461 if (dly++ > 5) {
3462 dly = 0;
3463 break;
3464 }
3465 udelay(10);
3466 }
3467 }
3468 dat.word = j->fskdata[j->cidcnt++];
3469 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471 cnt++;
3472 }
3473 if(j->cidcnt >= j->fskdcnt) {
3474 ixj_post_cid(j);
3475 }
3476 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477 and there is real audio data in the buffer, we need to throw it away because
3478 we just used it's time slot */
3479 if (j->write_buffer_rp > j->write_buffer_wp) {
3480 j->write_buffer_rp += j->cid_play_frame_size * 2;
3481 if (j->write_buffer_rp >= j->write_buffer_end) {
3482 j->write_buffer_rp = j->write_buffer;
3483 }
3484 j->write_buffers_empty++;
3485 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3486
3487 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3488 }
3489 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490 if (j->write_buffer_wp > j->write_buffer_rp) {
3491 frame_count =
3492 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493 }
3494 if (j->write_buffer_rp > j->write_buffer_wp) {
3495 frame_count =
3496 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498 }
3499 if (frame_count >= 1) {
3500 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501 BYTES blankword;
3502
3503 switch (j->play_mode) {
3504 case PLAYBACK_MODE_ULAW:
3505 case PLAYBACK_MODE_ALAW:
3506 blankword.low = blankword.high = 0xFF;
3507 break;
3508 case PLAYBACK_MODE_8LINEAR:
3509 case PLAYBACK_MODE_16LINEAR:
3510 default:
3511 blankword.low = blankword.high = 0x00;
3512 break;
3513 case PLAYBACK_MODE_8LINEAR_WSS:
3514 blankword.low = blankword.high = 0x80;
3515 break;
3516 }
3517 for (cnt = 0; cnt < 16; cnt++) {
3518 if (!(cnt % 16) && !IsTxReady(j)) {
3519 dly = 0;
3520 while (!IsTxReady(j)) {
3521 if (dly++ > 5) {
3522 dly = 0;
3523 break;
3524 }
3525 udelay(10);
3526 }
3527 }
3528 outb_p((blankword.low), j->DSPbase + 0x0C);
3529 outb_p((blankword.high), j->DSPbase + 0x0D);
3530 }
3531 j->flags.play_first_frame = 0;
3532 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533 for (cnt = 0; cnt < 24; cnt++) {
3534 BYTES blankword;
3535
3536 if(cnt == 12) {
3537 blankword.low = 0x02;
3538 blankword.high = 0x00;
3539 }
3540 else {
3541 blankword.low = blankword.high = 0x00;
3542 }
3543 if (!(cnt % 16) && !IsTxReady(j)) {
3544 dly = 0;
3545 while (!IsTxReady(j)) {
3546 if (dly++ > 5) {
3547 dly = 0;
3548 break;
3549 }
3550 udelay(10);
3551 }
3552 }
3553 outb_p((blankword.low), j->DSPbase + 0x0C);
3554 outb_p((blankword.high), j->DSPbase + 0x0D);
3555 }
3556 j->flags.play_first_frame = 0;
3557 }
3558 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559 if (!(cnt % 16) && !IsTxReady(j)) {
3560 dly = 0;
3561 while (!IsTxReady(j)) {
3562 if (dly++ > 5) {
3563 dly = 0;
3564 break;
3565 }
3566 udelay(10);
3567 }
3568 }
3569 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3570 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571 if (j->write_buffer_rp[cnt] == 0 &&
3572 j->write_buffer_rp[cnt + 1] == 0 &&
3573 j->write_buffer_rp[cnt + 2] == 0 &&
3574 j->write_buffer_rp[cnt + 3] == 0 &&
3575 j->write_buffer_rp[cnt + 4] == 0 &&
3576 j->write_buffer_rp[cnt + 5] == 0 &&
3577 j->write_buffer_rp[cnt + 6] == 0 &&
3578 j->write_buffer_rp[cnt + 7] == 0 &&
3579 j->write_buffer_rp[cnt + 8] == 0 &&
3580 j->write_buffer_rp[cnt + 9] == 0) {
3581 /* someone is trying to write silence lets make this a type 0 frame. */
3582 outb_p(0x00, j->DSPbase + 0x0C);
3583 outb_p(0x00, j->DSPbase + 0x0D);
3584 } else {
3585 /* so all other frames are type 1. */
3586 outb_p(0x01, j->DSPbase + 0x0C);
3587 outb_p(0x00, j->DSPbase + 0x0D);
3588 }
3589 }
3590 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592 *(j->write_buffer_rp + cnt) = 0;
3593 *(j->write_buffer_rp + cnt + 1) = 0;
3594 }
3595 j->write_buffer_rp += j->play_frame_size * 2;
3596 if (j->write_buffer_rp >= j->write_buffer_end) {
3597 j->write_buffer_rp = j->write_buffer;
3598 }
3599 j->write_buffers_empty++;
3600 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3601
3602 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3603
3604 ++j->frameswritten;
3605 }
3606 } else {
3607 j->drybuffer++;
3608 }
3609 if(j->ixj_signals[SIG_WRITE_READY]) {
3610 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611 }
3612 }
3613
3614 static int idle(IXJ *j)
3615 {
3616 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3617
3618 return 0;
3619
3620 if (j->ssr.high || j->ssr.low) {
3621 return 0;
3622 } else {
3623 j->play_mode = -1;
3624 j->flags.playing = 0;
3625 j->rec_mode = -1;
3626 j->flags.recording = 0;
3627 return 1;
3628 }
3629 }
3630
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633 unsigned short cmd;
3634 int cnt;
3635
3636 idle(j);
3637 j->cid_play_aec_level = j->aec_level;
3638 aec_stop(j);
3639 for (cnt = 0; cnt < 10; cnt++) {
3640 if (idle(j))
3641 break;
3642 }
3643 if (j->ssr.high || j->ssr.low)
3644 return -1;
3645 if (j->dsp.low != 0x20) {
3646 switch (size) {
3647 case 30:
3648 cmd = 0x07F0;
3649 /* Set Base Frame Size to 240 pg9-10 8021 */
3650 break;
3651 case 20:
3652 cmd = 0x07A0;
3653 /* Set Base Frame Size to 160 pg9-10 8021 */
3654 break;
3655 case 10:
3656 cmd = 0x0750;
3657 /* Set Base Frame Size to 80 pg9-10 8021 */
3658 break;
3659 default:
3660 return -1;
3661 }
3662 } else {
3663 if (size == 30)
3664 return size;
3665 else
3666 return -1;
3667 }
3668 if (ixj_WriteDSPCommand(cmd, j)) {
3669 j->baseframe.high = j->baseframe.low = 0xFF;
3670 return -1;
3671 } else {
3672 j->baseframe.high = j->ssr.high;
3673 j->baseframe.low = j->ssr.low;
3674 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676 return -1;
3677 }
3678 }
3679 ixj_aec_start(j, j->cid_play_aec_level);
3680 return size;
3681 }
3682
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685 int retval = 0;
3686
3687 j->rec_codec = rate;
3688
3689 switch (rate) {
3690 case G723_63:
3691 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692 j->rec_frame_size = 12;
3693 j->rec_mode = 0;
3694 } else {
3695 retval = 1;
3696 }
3697 break;
3698 case G723_53:
3699 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700 j->rec_frame_size = 10;
3701 j->rec_mode = 0;
3702 } else {
3703 retval = 1;
3704 }
3705 break;
3706 case TS85:
3707 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708 j->rec_frame_size = 16;
3709 j->rec_mode = 0;
3710 } else {
3711 retval = 1;
3712 }
3713 break;
3714 case TS48:
3715 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716 j->rec_frame_size = 9;
3717 j->rec_mode = 0;
3718 } else {
3719 retval = 1;
3720 }
3721 break;
3722 case TS41:
3723 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724 j->rec_frame_size = 8;
3725 j->rec_mode = 0;
3726 } else {
3727 retval = 1;
3728 }
3729 break;
3730 case G728:
3731 if (j->dsp.low != 0x20) {
3732 j->rec_frame_size = 48;
3733 j->rec_mode = 0;
3734 } else {
3735 retval = 1;
3736 }
3737 break;
3738 case G729:
3739 if (j->dsp.low != 0x20) {
3740 if (!j->flags.g729_loaded) {
3741 retval = 1;
3742 break;
3743 }
3744 switch (j->baseframe.low) {
3745 case 0xA0:
3746 j->rec_frame_size = 10;
3747 break;
3748 case 0x50:
3749 j->rec_frame_size = 5;
3750 break;
3751 default:
3752 j->rec_frame_size = 15;
3753 break;
3754 }
3755 j->rec_mode = 0;
3756 } else {
3757 retval = 1;
3758 }
3759 break;
3760 case G729B:
3761 if (j->dsp.low != 0x20) {
3762 if (!j->flags.g729_loaded) {
3763 retval = 1;
3764 break;
3765 }
3766 switch (j->baseframe.low) {
3767 case 0xA0:
3768 j->rec_frame_size = 12;
3769 break;
3770 case 0x50:
3771 j->rec_frame_size = 6;
3772 break;
3773 default:
3774 j->rec_frame_size = 18;
3775 break;
3776 }
3777 j->rec_mode = 0;
3778 } else {
3779 retval = 1;
3780 }
3781 break;
3782 case ULAW:
3783 switch (j->baseframe.low) {
3784 case 0xA0:
3785 j->rec_frame_size = 80;
3786 break;
3787 case 0x50:
3788 j->rec_frame_size = 40;
3789 break;
3790 default:
3791 j->rec_frame_size = 120;
3792 break;
3793 }
3794 j->rec_mode = 4;
3795 break;
3796 case ALAW:
3797 switch (j->baseframe.low) {
3798 case 0xA0:
3799 j->rec_frame_size = 80;
3800 break;
3801 case 0x50:
3802 j->rec_frame_size = 40;
3803 break;
3804 default:
3805 j->rec_frame_size = 120;
3806 break;
3807 }
3808 j->rec_mode = 4;
3809 break;
3810 case LINEAR16:
3811 switch (j->baseframe.low) {
3812 case 0xA0:
3813 j->rec_frame_size = 160;
3814 break;
3815 case 0x50:
3816 j->rec_frame_size = 80;
3817 break;
3818 default:
3819 j->rec_frame_size = 240;
3820 break;
3821 }
3822 j->rec_mode = 5;
3823 break;
3824 case LINEAR8:
3825 switch (j->baseframe.low) {
3826 case 0xA0:
3827 j->rec_frame_size = 80;
3828 break;
3829 case 0x50:
3830 j->rec_frame_size = 40;
3831 break;
3832 default:
3833 j->rec_frame_size = 120;
3834 break;
3835 }
3836 j->rec_mode = 6;
3837 break;
3838 case WSS:
3839 switch (j->baseframe.low) {
3840 case 0xA0:
3841 j->rec_frame_size = 80;
3842 break;
3843 case 0x50:
3844 j->rec_frame_size = 40;
3845 break;
3846 default:
3847 j->rec_frame_size = 120;
3848 break;
3849 }
3850 j->rec_mode = 7;
3851 break;
3852 default:
3853 kfree(j->read_buffer);
3854 j->rec_frame_size = 0;
3855 j->rec_mode = -1;
3856 j->read_buffer = NULL;
3857 j->read_buffer_size = 0;
3858 retval = 1;
3859 break;
3860 }
3861 return retval;
3862 }
3863
3864 static int ixj_record_start(IXJ *j)
3865 {
3866 unsigned short cmd = 0x0000;
3867
3868 if (j->read_buffer) {
3869 ixj_record_stop(j);
3870 }
3871 j->flags.recording = 1;
3872 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874 if(ixjdebug & 0x0002)
3875 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877 if (!j->rec_mode) {
3878 switch (j->rec_codec) {
3879 case G723_63:
3880 cmd = 0x5131;
3881 break;
3882 case G723_53:
3883 cmd = 0x5132;
3884 break;
3885 case TS85:
3886 cmd = 0x5130; /* TrueSpeech 8.5 */
3887
3888 break;
3889 case TS48:
3890 cmd = 0x5133; /* TrueSpeech 4.8 */
3891
3892 break;
3893 case TS41:
3894 cmd = 0x5134; /* TrueSpeech 4.1 */
3895
3896 break;
3897 case G728:
3898 cmd = 0x5135;
3899 break;
3900 case G729:
3901 case G729B:
3902 cmd = 0x5136;
3903 break;
3904 default:
3905 return 1;
3906 }
3907 if (ixj_WriteDSPCommand(cmd, j))
3908 return -1;
3909 }
3910 if (!j->read_buffer) {
3911 if (!j->read_buffer)
3912 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913 if (!j->read_buffer) {
3914 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915 return -ENOMEM;
3916 }
3917 }
3918 j->read_buffer_size = j->rec_frame_size * 2;
3919
3920 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3921
3922 return -1;
3923
3924 switch (j->rec_mode) {
3925 case 0:
3926 cmd = 0x1C03; /* Record C1 */
3927
3928 break;
3929 case 4:
3930 if (j->ver.low == 0x12) {
3931 cmd = 0x1E03; /* Record C1 */
3932
3933 } else {
3934 cmd = 0x1E01; /* Record C1 */
3935
3936 }
3937 break;
3938 case 5:
3939 if (j->ver.low == 0x12) {
3940 cmd = 0x1E83; /* Record C1 */
3941
3942 } else {
3943 cmd = 0x1E81; /* Record C1 */
3944
3945 }
3946 break;
3947 case 6:
3948 if (j->ver.low == 0x12) {
3949 cmd = 0x1F03; /* Record C1 */
3950
3951 } else {
3952 cmd = 0x1F01; /* Record C1 */
3953
3954 }
3955 break;
3956 case 7:
3957 if (j->ver.low == 0x12) {
3958 cmd = 0x1F83; /* Record C1 */
3959 } else {
3960 cmd = 0x1F81; /* Record C1 */
3961 }
3962 break;
3963 }
3964 if (ixj_WriteDSPCommand(cmd, j))
3965 return -1;
3966
3967 if (j->flags.playing) {
3968 ixj_aec_start(j, j->aec_level);
3969 }
3970 return 0;
3971 }
3972
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975 if (ixjdebug & 0x0002)
3976 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978 kfree(j->read_buffer);
3979 j->read_buffer = NULL;
3980 j->read_buffer_size = 0;
3981 if (j->rec_mode > -1) {
3982 ixj_WriteDSPCommand(0x5120, j);
3983 j->rec_mode = -1;
3984 }
3985 j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989 if (arg)
3990 ixj_WriteDSPCommand(0x513F, j);
3991 else
3992 ixj_WriteDSPCommand(0x513E, j);
3993 }
3994
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997 if (depth > 60)
3998 depth = 60;
3999 if (depth < 0)
4000 depth = 0;
4001 ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006 ixj_WriteDSPCommand(0xCF07, j);
4007 ixj_WriteDSPCommand(volume, j);
4008 }
4009
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012 ixj_WriteDSPCommand(0xCF05, j);
4013 return j->ssr.high << 8 | j->ssr.low;
4014 }
4015
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018 if(j->aec_level == AEC_AGC) {
4019 if (ixjdebug & 0x0002)
4020 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021 ixj_WriteDSPCommand(0xCF96, j);
4022 ixj_WriteDSPCommand(volume, j);
4023 } else {
4024 if (ixjdebug & 0x0002)
4025 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026 ixj_WriteDSPCommand(0xCF03, j);
4027 ixj_WriteDSPCommand(volume, j);
4028 }
4029 }
4030
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033 int newvolume, dsprecmax;
4034
4035 if (ixjdebug & 0x0002)
4036 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037 if(volume > 100 || volume < 0) {
4038 return -1;
4039 }
4040
4041 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042 switch (j->cardtype) {
4043 case QTI_PHONEJACK:
4044 dsprecmax = 0x440;
4045 break;
4046 case QTI_LINEJACK:
4047 dsprecmax = 0x180;
4048 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4049 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4050 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4051 break;
4052 case QTI_PHONEJACK_LITE:
4053 dsprecmax = 0x4C0;
4054 break;
4055 case QTI_PHONEJACK_PCI:
4056 dsprecmax = 0x100;
4057 break;
4058 case QTI_PHONECARD:
4059 dsprecmax = 0x400;
4060 break;
4061 default:
4062 return -1;
4063 }
4064 newvolume = (dsprecmax * volume) / 100;
4065 set_rec_volume(j, newvolume);
4066 return 0;
4067 }
4068
4069 static int get_rec_volume(IXJ *j)
4070 {
4071 if(j->aec_level == AEC_AGC) {
4072 if (ixjdebug & 0x0002)
4073 printk(KERN_INFO "Getting AGC Threshold\n");
4074 ixj_WriteDSPCommand(0xCF86, j);
4075 if (ixjdebug & 0x0002)
4076 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077 return j->ssr.high << 8 | j->ssr.low;
4078 } else {
4079 if (ixjdebug & 0x0002)
4080 printk(KERN_INFO "Getting Record Volume\n");
4081 ixj_WriteDSPCommand(0xCF01, j);
4082 return j->ssr.high << 8 | j->ssr.low;
4083 }
4084 }
4085
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088 int volume, newvolume, dsprecmax;
4089
4090 switch (j->cardtype) {
4091 case QTI_PHONEJACK:
4092 dsprecmax = 0x440;
4093 break;
4094 case QTI_LINEJACK:
4095 dsprecmax = 0x180;
4096 break;
4097 case QTI_PHONEJACK_LITE:
4098 dsprecmax = 0x4C0;
4099 break;
4100 case QTI_PHONEJACK_PCI:
4101 dsprecmax = 0x100;
4102 break;
4103 case QTI_PHONECARD:
4104 dsprecmax = 0x400;
4105 break;
4106 default:
4107 return -1;
4108 }
4109 volume = get_rec_volume(j);
4110 newvolume = (volume * 100) / dsprecmax;
4111 if(newvolume > 100)
4112 newvolume = 100;
4113 return newvolume;
4114 }
4115
4116 static int get_rec_level(IXJ *j)
4117 {
4118 int retval;
4119
4120 ixj_WriteDSPCommand(0xCF88, j);
4121
4122 retval = j->ssr.high << 8 | j->ssr.low;
4123 retval = (retval * 256) / 240;
4124 return retval;
4125 }
4126
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129 j->aec_level = level;
4130 if (ixjdebug & 0x0002)
4131 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132 if (!level) {
4133 aec_stop(j);
4134 } else {
4135 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138 ixj_WriteDSPCommand(0x0300, j);
4139 }
4140 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144 switch (level) {
4145 case AEC_LOW:
4146 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148 ixj_WriteDSPCommand(0xE011, j);
4149 ixj_WriteDSPCommand(0xFFFF, j);
4150
4151 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152 ixj_WriteDSPCommand(0x0000, j); /* to off */
4153
4154 break;
4155
4156 case AEC_MED:
4157 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159 ixj_WriteDSPCommand(0xE011, j);
4160 ixj_WriteDSPCommand(0x0080, j);
4161
4162 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163 ixj_WriteDSPCommand(0x0000, j); /* to off */
4164
4165 break;
4166
4167 case AEC_HIGH:
4168 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170 ixj_WriteDSPCommand(0xE011, j);
4171 ixj_WriteDSPCommand(0x0080, j);
4172
4173 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174 ixj_WriteDSPCommand(0x0000, j); /* to off */
4175
4176 break;
4177
4178 case AEC_AGC:
4179 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182 ixj_WriteDSPCommand(0xE011, j);
4183 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188 ixj_WriteDSPCommand(0x0224, j);
4189 else
4190 ixj_WriteDSPCommand(0x1224, j);
4191
4192 ixj_WriteDSPCommand(0xE014, j);
4193 ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4194
4195 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197 /* Now we can set the AGC initial parameters and turn it on */
4198 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4199 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220 ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222 break;
4223
4224 case AEC_AUTO:
4225 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227 ixj_WriteDSPCommand(0xE011, j);
4228 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233 ixj_WriteDSPCommand(0x0224, j);
4234 else
4235 ixj_WriteDSPCommand(0x1224, j);
4236
4237 ixj_WriteDSPCommand(0xE014, j);
4238 ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4239
4240 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242 break;
4243 }
4244 }
4245 }
4246
4247 static void aec_stop(IXJ *j)
4248 {
4249 j->aec_level = AEC_OFF;
4250 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253 ixj_WriteDSPCommand(0x0700, j);
4254 }
4255 if (j->play_mode != -1 && j->rec_mode != -1)
4256 {
4257 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258 }
4259 }
4260
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263 int retval = 0;
4264
4265 j->play_codec = rate;
4266
4267 switch (rate) {
4268 case G723_63:
4269 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270 j->play_frame_size = 12;
4271 j->play_mode = 0;
4272 } else {
4273 retval = 1;
4274 }
4275 break;
4276 case G723_53:
4277 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278 j->play_frame_size = 10;
4279 j->play_mode = 0;
4280 } else {
4281 retval = 1;
4282 }
4283 break;
4284 case TS85:
4285 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286 j->play_frame_size = 16;
4287 j->play_mode = 0;
4288 } else {
4289 retval = 1;
4290 }
4291 break;
4292 case TS48:
4293 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294 j->play_frame_size = 9;
4295 j->play_mode = 0;
4296 } else {
4297 retval = 1;
4298 }
4299 break;
4300 case TS41:
4301 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302 j->play_frame_size = 8;
4303 j->play_mode = 0;
4304 } else {
4305 retval = 1;
4306 }
4307 break;
4308 case G728:
4309 if (j->dsp.low != 0x20) {
4310 j->play_frame_size = 48;
4311 j->play_mode = 0;
4312 } else {
4313 retval = 1;
4314 }
4315 break;
4316 case G729:
4317 if (j->dsp.low != 0x20) {
4318 if (!j->flags.g729_loaded) {
4319 retval = 1;
4320 break;
4321 }
4322 switch (j->baseframe.low) {
4323 case 0xA0:
4324 j->play_frame_size = 10;
4325 break;
4326 case 0x50:
4327 j->play_frame_size = 5;
4328 break;
4329 default:
4330 j->play_frame_size = 15;
4331 break;
4332 }
4333 j->play_mode = 0;
4334 } else {
4335 retval = 1;
4336 }
4337 break;
4338 case G729B:
4339 if (j->dsp.low != 0x20) {
4340 if (!j->flags.g729_loaded) {
4341 retval = 1;
4342 break;
4343 }
4344 switch (j->baseframe.low) {
4345 case 0xA0:
4346 j->play_frame_size = 12;
4347 break;
4348 case 0x50:
4349 j->play_frame_size = 6;
4350 break;
4351 default:
4352 j->play_frame_size = 18;
4353 break;
4354 }
4355 j->play_mode = 0;
4356 } else {
4357 retval = 1;
4358 }
4359 break;
4360 case ULAW:
4361 switch (j->baseframe.low) {
4362 case 0xA0:
4363 j->play_frame_size = 80;
4364 break;
4365 case 0x50:
4366 j->play_frame_size = 40;
4367 break;
4368 default:
4369 j->play_frame_size = 120;
4370 break;
4371 }
4372 j->play_mode = 2;
4373 break;
4374 case ALAW:
4375 switch (j->baseframe.low) {
4376 case 0xA0:
4377 j->play_frame_size = 80;
4378 break;
4379 case 0x50:
4380 j->play_frame_size = 40;
4381 break;
4382 default:
4383 j->play_frame_size = 120;
4384 break;
4385 }
4386 j->play_mode = 2;
4387 break;
4388 case LINEAR16:
4389 switch (j->baseframe.low) {
4390 case 0xA0:
4391 j->play_frame_size = 160;
4392 break;
4393 case 0x50:
4394 j->play_frame_size = 80;
4395 break;
4396 default:
4397 j->play_frame_size = 240;
4398 break;
4399 }
4400 j->play_mode = 6;
4401 break;
4402 case LINEAR8:
4403 switch (j->baseframe.low) {
4404 case 0xA0:
4405 j->play_frame_size = 80;
4406 break;
4407 case 0x50:
4408 j->play_frame_size = 40;
4409 break;
4410 default:
4411 j->play_frame_size = 120;
4412 break;
4413 }
4414 j->play_mode = 4;
4415 break;
4416 case WSS:
4417 switch (j->baseframe.low) {
4418 case 0xA0:
4419 j->play_frame_size = 80;
4420 break;
4421 case 0x50:
4422 j->play_frame_size = 40;
4423 break;
4424 default:
4425 j->play_frame_size = 120;
4426 break;
4427 }
4428 j->play_mode = 5;
4429 break;
4430 default:
4431 kfree(j->write_buffer);
4432 j->play_frame_size = 0;
4433 j->play_mode = -1;
4434 j->write_buffer = NULL;
4435 j->write_buffer_size = 0;
4436 retval = 1;
4437 break;
4438 }
4439 return retval;
4440 }
4441
4442 static int ixj_play_start(IXJ *j)
4443 {
4444 unsigned short cmd = 0x0000;
4445
4446 if (j->write_buffer) {
4447 ixj_play_stop(j);
4448 }
4449
4450 if(ixjdebug & 0x0002)
4451 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453 j->flags.playing = 1;
4454 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456 j->flags.play_first_frame = 1;
4457 j->drybuffer = 0;
4458
4459 if (!j->play_mode) {
4460 switch (j->play_codec) {
4461 case G723_63:
4462 cmd = 0x5231;
4463 break;
4464 case G723_53:
4465 cmd = 0x5232;
4466 break;
4467 case TS85:
4468 cmd = 0x5230; /* TrueSpeech 8.5 */
4469
4470 break;
4471 case TS48:
4472 cmd = 0x5233; /* TrueSpeech 4.8 */
4473
4474 break;
4475 case TS41:
4476 cmd = 0x5234; /* TrueSpeech 4.1 */
4477
4478 break;
4479 case G728:
4480 cmd = 0x5235;
4481 break;
4482 case G729:
4483 case G729B:
4484 cmd = 0x5236;
4485 break;
4486 default:
4487 return 1;
4488 }
4489 if (ixj_WriteDSPCommand(cmd, j))
4490 return -1;
4491 }
4492 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493 if (!j->write_buffer) {
4494 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495 return -ENOMEM;
4496 }
4497 /* j->write_buffers_empty = 2; */
4498 j->write_buffers_empty = 1;
4499 j->write_buffer_size = j->play_frame_size * 2;
4500 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4504
4505 return -1;
4506
4507 switch (j->play_mode) {
4508 case 0:
4509 cmd = 0x2C03;
4510 break;
4511 case 2:
4512 if (j->ver.low == 0x12) {
4513 cmd = 0x2C23;
4514 } else {
4515 cmd = 0x2C21;
4516 }
4517 break;
4518 case 4:
4519 if (j->ver.low == 0x12) {
4520 cmd = 0x2C43;
4521 } else {
4522 cmd = 0x2C41;
4523 }
4524 break;
4525 case 5:
4526 if (j->ver.low == 0x12) {
4527 cmd = 0x2C53;
4528 } else {
4529 cmd = 0x2C51;
4530 }
4531 break;
4532 case 6:
4533 if (j->ver.low == 0x12) {
4534 cmd = 0x2C63;
4535 } else {
4536 cmd = 0x2C61;
4537 }
4538 break;
4539 }
4540 if (ixj_WriteDSPCommand(cmd, j))
4541 return -1;
4542
4543 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4544 return -1;
4545
4546 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4547 return -1;
4548
4549 if (j->flags.recording) {
4550 ixj_aec_start(j, j->aec_level);
4551 }
4552
4553 return 0;
4554 }
4555
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558 if (ixjdebug & 0x0002)
4559 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561 kfree(j->write_buffer);
4562 j->write_buffer = NULL;
4563 j->write_buffer_size = 0;
4564 if (j->play_mode > -1) {
4565 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4566
4567 j->play_mode = -1;
4568 }
4569 j->flags.playing = 0;
4570 }
4571
4572 static inline int get_play_level(IXJ *j)
4573 {
4574 int retval;
4575
4576 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577 return j->ssr.high << 8 | j->ssr.low;
4578 retval = j->ssr.high << 8 | j->ssr.low;
4579 retval = (retval * 256) / 240;
4580 return retval;
4581 }
4582
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585 unsigned int mask = 0;
4586
4587 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588
4589 poll_wait(file_p, &(j->poll_q), wait);
4590 if (j->read_buffer_ready > 0)
4591 mask |= POLLIN | POLLRDNORM; /* readable */
4592 if (j->write_buffers_empty > 0)
4593 mask |= POLLOUT | POLLWRNORM; /* writable */
4594 if (j->ex.bytes)
4595 mask |= POLLPRI;
4596 return mask;
4597 }
4598
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601 if (!j->tone_state) {
4602 if(ixjdebug & 0x0002) {
4603 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604 }
4605 if (j->dsp.low == 0x20) {
4606 idle(j);
4607 }
4608 j->tone_start_jif = jiffies;
4609
4610 j->tone_state = 1;
4611 }
4612
4613 j->tone_index = tone;
4614 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615 return -1;
4616
4617 return 0;
4618 }
4619
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622 j->tone_on_time = arg;
4623
4624 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4625
4626 return -1;
4627
4628 if (ixj_WriteDSPCommand(arg, j))
4629 return -1;
4630
4631 return 0;
4632 }
4633
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636 int cnt;
4637
4638 j->pld_scrr.byte = inb_p(j->XILINXbase);
4639 if (!j->pld_scrr.bits.sci) {
4640 for (cnt = 0; cnt < 10; cnt++) {
4641 udelay(32);
4642 j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644 if ((j->pld_scrr.bits.sci))
4645 return 1;
4646 }
4647 if (ixjdebug & 0x0001)
4648 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649 return 0;
4650 } else
4651 return 1;
4652 }
4653
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656 int cnt;
4657
4658 j->pld_scrr.byte = inb_p(j->XILINXbase);
4659 if (j->pld_scrr.bits.sci) {
4660 for (cnt = 0; cnt < 10; cnt++) {
4661 udelay(32);
4662 j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664 if (!(j->pld_scrr.bits.sci))
4665 return 1;
4666 }
4667 if (ixjdebug & 0x0001)
4668 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669 return 0;
4670 } else
4671 return 1;
4672 }
4673
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676 switch (control) {
4677 case SCI_End:
4678 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4679
4680 j->pld_scrw.bits.c1 = 0; /* to no selection */
4681
4682 break;
4683 case SCI_Enable_DAA:
4684 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4685
4686 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4687
4688 break;
4689 case SCI_Enable_Mixer:
4690 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4691
4692 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4693
4694 break;
4695 case SCI_Enable_EEPROM:
4696 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4697
4698 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4699
4700 break;
4701 default:
4702 return 0;
4703 break;
4704 }
4705 outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707 switch (control) {
4708 case SCI_End:
4709 return 1;
4710 break;
4711 case SCI_Enable_DAA:
4712 case SCI_Enable_Mixer:
4713 case SCI_Enable_EEPROM:
4714 if (!SCI_WaitHighSCI(j))
4715 return 0;
4716 break;
4717 default:
4718 return 0;
4719 break;
4720 }
4721 return 1;
4722 }
4723
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726 if (!SCI_Control(j, SCI_End))
4727 return 0;
4728
4729 if (!SCI_WaitLowSCI(j))
4730 return 0;
4731
4732 return 1;
4733 }
4734
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737 int reg = (val & 0x1F00) >> 8;
4738 return j->mix.vol[reg];
4739 }
4740
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743 BYTES bytes;
4744
4745 bytes.high = (val & 0x1F00) >> 8;
4746 bytes.low = val & 0x00FF;
4747
4748 /* save mixer value so we can get back later on */
4749 j->mix.vol[bytes.high] = bytes.low;
4750
4751 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4752
4753 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4754
4755 SCI_Control(j, SCI_Enable_Mixer);
4756
4757 SCI_Control(j, SCI_End);
4758
4759 return 0;
4760 }
4761
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766 if (!SCI_Control(j, SCI_Enable_DAA))
4767 return 0;
4768 else
4769 return 1;
4770 }
4771
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774 BYTES bytes;
4775
4776 switch (j->daa_mode) {
4777 case SOP_PU_SLEEP:
4778 bytes.high = 0x14;
4779 break;
4780 case SOP_PU_RINGING:
4781 bytes.high = 0x54;
4782 break;
4783 case SOP_PU_CONVERSATION:
4784 bytes.high = 0x94;
4785 break;
4786 case SOP_PU_PULSEDIALING:
4787 bytes.high = 0xD4;
4788 break;
4789 }
4790
4791 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794 case 0:
4795 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796 break;
4797 case 1:
4798 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799 break;
4800 case 2:
4801 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802 break;
4803 case 3:
4804 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805 break;
4806 }
4807
4808 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810 if (!daa_load(&bytes, j))
4811 return 0;
4812
4813 if (!SCI_Prepare(j))
4814 return 0;
4815
4816 return 1;
4817 }
4818
4819 static char daa_int_read(IXJ *j)
4820 {
4821 BYTES bytes;
4822
4823 if (!SCI_Prepare(j))
4824 return 0;
4825
4826 bytes.high = 0x38;
4827 bytes.low = 0x00;
4828 outb_p(bytes.high, j->XILINXbase + 0x03);
4829 outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831 if (!SCI_Control(j, SCI_Enable_DAA))
4832 return 0;
4833
4834 bytes.high = inb_p(j->XILINXbase + 0x03);
4835 bytes.low = inb_p(j->XILINXbase + 0x02);
4836 if (bytes.low != ALISDAA_ID_BYTE) {
4837 if (ixjdebug & 0x0001)
4838 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839 return 0;
4840 }
4841 if (!SCI_Control(j, SCI_Enable_DAA))
4842 return 0;
4843 if (!SCI_Control(j, SCI_End))
4844 return 0;
4845
4846 bytes.high = inb_p(j->XILINXbase + 0x03);
4847 bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851 return 1;
4852 }
4853
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856 IXJ_WORD wdata;
4857 BYTES bytes;
4858
4859 if (!SCI_Prepare(j))
4860 return 0;
4861
4862 switch (j->daa_mode) {
4863 case SOP_PU_SLEEP:
4864 bytes.high = 0x30 + cr;
4865 break;
4866 case SOP_PU_RINGING:
4867 bytes.high = 0x70 + cr;
4868 break;
4869 case SOP_PU_CONVERSATION:
4870 bytes.high = 0xB0 + cr;
4871 break;
4872 case SOP_PU_PULSEDIALING:
4873 default:
4874 bytes.high = 0xF0 + cr;
4875 break;
4876 }
4877
4878 bytes.low = 0x00;
4879
4880 outb_p(bytes.high, j->XILINXbase + 0x03);
4881 outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883 if (!SCI_Control(j, SCI_Enable_DAA))
4884 return 0;
4885
4886 bytes.high = inb_p(j->XILINXbase + 0x03);
4887 bytes.low = inb_p(j->XILINXbase + 0x02);
4888 if (bytes.low != ALISDAA_ID_BYTE) {
4889 if (ixjdebug & 0x0001)
4890 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891 return 0;
4892 }
4893 if (!SCI_Control(j, SCI_Enable_DAA))
4894 return 0;
4895 if (!SCI_Control(j, SCI_End))
4896 return 0;
4897
4898 wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900 switch(cr){
4901 case 5:
4902 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903 break;
4904 case 4:
4905 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906 break;
4907 case 3:
4908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909 break;
4910 case 2:
4911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912 break;
4913 case 1:
4914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915 break;
4916 case 0:
4917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918 break;
4919 default:
4920 return 0;
4921 }
4922 return 1;
4923 }
4924
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927 int i;
4928 BYTES bytes;
4929
4930 if (ixjdebug & 0x0002)
4931 printk("DAA Clearing CID ram\n");
4932
4933 if (!SCI_Prepare(j))
4934 return 0;
4935
4936 bytes.high = 0x58;
4937 bytes.low = 0x00;
4938 outb_p(bytes.high, j->XILINXbase + 0x03);
4939 outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941 if (!SCI_Control(j, SCI_Enable_DAA))
4942 return 0;
4943
4944 if (!SCI_WaitHighSCI(j))
4945 return 0;
4946
4947 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948 bytes.high = bytes.low = 0x00;
4949 outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951 if (i < ALISDAA_CALLERID_SIZE - 1)
4952 outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954 if (!SCI_Control(j, SCI_Enable_DAA))
4955 return 0;
4956
4957 if (!SCI_WaitHighSCI(j))
4958 return 0;
4959
4960 }
4961
4962 if (!SCI_Control(j, SCI_End))
4963 return 0;
4964
4965 if (ixjdebug & 0x0002)
4966 printk("DAA CID ram cleared\n");
4967
4968 return 1;
4969 }
4970
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973 int i;
4974 BYTES bytes;
4975 char CID[ALISDAA_CALLERID_SIZE];
4976 bool mContinue;
4977 char *pIn, *pOut;
4978
4979 if (!SCI_Prepare(j))
4980 return 0;
4981
4982 bytes.high = 0x78;
4983 bytes.low = 0x00;
4984 outb_p(bytes.high, j->XILINXbase + 0x03);
4985 outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987 if (!SCI_Control(j, SCI_Enable_DAA))
4988 return 0;
4989
4990 if (!SCI_WaitHighSCI(j))
4991 return 0;
4992
4993 bytes.high = inb_p(j->XILINXbase + 0x03);
4994 bytes.low = inb_p(j->XILINXbase + 0x02);
4995 if (bytes.low != ALISDAA_ID_BYTE) {
4996 if (ixjdebug & 0x0001)
4997 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998 return 0;
4999 }
5000 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001 bytes.high = bytes.low = 0x00;
5002 outb_p(bytes.high, j->XILINXbase + 0x03);
5003 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005 if (!SCI_Control(j, SCI_Enable_DAA))
5006 return 0;
5007
5008 if (!SCI_WaitHighSCI(j))
5009 return 0;
5010
5011 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013 }
5014
5015 if (!SCI_Control(j, SCI_End))
5016 return 0;
5017
5018 pIn = CID;
5019 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020 mContinue = true;
5021 while (mContinue) {
5022 if ((pIn[1] & 0x03) == 0x01) {
5023 pOut[0] = pIn[0];
5024 }
5025 if ((pIn[2] & 0x0c) == 0x04) {
5026 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027 }
5028 if ((pIn[3] & 0x30) == 0x10) {
5029 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030 }
5031 if ((pIn[4] & 0xc0) == 0x40) {
5032 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033 } else {
5034 mContinue = false;
5035 }
5036 pIn += 5, pOut += 4;
5037 }
5038 memset(&j->cid, 0, sizeof(PHONE_CID));
5039 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040 pOut += 4;
5041 strncpy(j->cid.month, pOut, 2);
5042 pOut += 2;
5043 strncpy(j->cid.day, pOut, 2);
5044 pOut += 2;
5045 strncpy(j->cid.hour, pOut, 2);
5046 pOut += 2;
5047 strncpy(j->cid.min, pOut, 2);
5048 pOut += 3;
5049 j->cid.numlen = *pOut;
5050 pOut += 1;
5051 strncpy(j->cid.number, pOut, j->cid.numlen);
5052 pOut += j->cid.numlen + 1;
5053 j->cid.namelen = *pOut;
5054 pOut += 1;
5055 strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057 ixj_daa_cid_reset(j);
5058 return 1;
5059 }
5060
5061 static char daa_get_version(IXJ *j)
5062 {
5063 BYTES bytes;
5064
5065 if (!SCI_Prepare(j))
5066 return 0;
5067
5068 bytes.high = 0x35;
5069 bytes.low = 0x00;
5070 outb_p(bytes.high, j->XILINXbase + 0x03);
5071 outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073 if (!SCI_Control(j, SCI_Enable_DAA))
5074 return 0;
5075
5076 bytes.high = inb_p(j->XILINXbase + 0x03);
5077 bytes.low = inb_p(j->XILINXbase + 0x02);
5078 if (bytes.low != ALISDAA_ID_BYTE) {
5079 if (ixjdebug & 0x0001)
5080 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081 return 0;
5082 }
5083 if (!SCI_Control(j, SCI_Enable_DAA))
5084 return 0;
5085
5086 if (!SCI_Control(j, SCI_End))
5087 return 0;
5088
5089 bytes.high = inb_p(j->XILINXbase + 0x03);
5090 bytes.low = inb_p(j->XILINXbase + 0x02);
5091 if (ixjdebug & 0x0002)
5092 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094 return bytes.high;
5095 }
5096
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099 /* NOTE:
5100 The DAA *MUST* be in the conversation mode if the
5101 PSTN line is to be seized (PSTN line off-hook).
5102 Taking the PSTN line off-hook while the DAA is in
5103 a mode other than conversation mode will cause a
5104 hardware failure of the ALIS-A part.
5105
5106 NOTE:
5107 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108 if the PSTN line is on-hook. Failure to have the PSTN line
5109 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110 ALIS-A part.
5111 */
5112
5113 BYTES bytes;
5114
5115 j->flags.pstn_rmr = 0;
5116
5117 if (!SCI_Prepare(j))
5118 return 0;
5119
5120 switch (mode) {
5121 case SOP_PU_RESET:
5122 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5123
5124 outb_p(j->pld_scrw.byte, j->XILINXbase);
5125 j->pld_slicw.bits.rly2 = 0;
5126 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127 bytes.high = 0x10;
5128 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129 daa_load(&bytes, j);
5130 if (!SCI_Prepare(j))
5131 return 0;
5132
5133 j->daa_mode = SOP_PU_SLEEP;
5134 break;
5135 case SOP_PU_SLEEP:
5136 if(j->daa_mode == SOP_PU_SLEEP)
5137 {
5138 break;
5139 }
5140 if (ixjdebug & 0x0008)
5141 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /* if(j->daa_mode == SOP_PU_CONVERSATION) */
5143 {
5144 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5145
5146 outb_p(j->pld_scrw.byte, j->XILINXbase);
5147 j->pld_slicw.bits.rly2 = 0;
5148 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149 bytes.high = 0x10;
5150 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151 daa_load(&bytes, j);
5152 if (!SCI_Prepare(j))
5153 return 0;
5154 }
5155 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5156
5157 outb_p(j->pld_scrw.byte, j->XILINXbase);
5158 j->pld_slicw.bits.rly2 = 0;
5159 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160 bytes.high = 0x10;
5161 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162 daa_load(&bytes, j);
5163 if (!SCI_Prepare(j))
5164 return 0;
5165
5166 j->daa_mode = SOP_PU_SLEEP;
5167 j->flags.pstn_ringing = 0;
5168 j->ex.bits.pstn_ring = 0;
5169 j->pstn_sleeptil = jiffies + (hertz / 4);
5170 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5171 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5172 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5173 break;
5174 case SOP_PU_RINGING:
5175 if (ixjdebug & 0x0008)
5176 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5178
5179 outb_p(j->pld_scrw.byte, j->XILINXbase);
5180 j->pld_slicw.bits.rly2 = 0;
5181 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182 bytes.high = 0x50;
5183 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184 daa_load(&bytes, j);
5185 if (!SCI_Prepare(j))
5186 return 0;
5187 j->daa_mode = SOP_PU_RINGING;
5188 break;
5189 case SOP_PU_CONVERSATION:
5190 if (ixjdebug & 0x0008)
5191 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192 bytes.high = 0x90;
5193 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194 daa_load(&bytes, j);
5195 if (!SCI_Prepare(j))
5196 return 0;
5197 j->pld_slicw.bits.rly2 = 1;
5198 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5200
5201 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202 j->daa_mode = SOP_PU_CONVERSATION;
5203 j->flags.pstn_ringing = 0;
5204 j->ex.bits.pstn_ring = 0;
5205 j->pstn_sleeptil = jiffies;
5206 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207 break;
5208 case SOP_PU_PULSEDIALING:
5209 if (ixjdebug & 0x0008)
5210 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5212
5213 outb_p(j->pld_scrw.byte, j->XILINXbase);
5214 j->pld_slicw.bits.rly2 = 0;
5215 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216 bytes.high = 0xD0;
5217 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218 daa_load(&bytes, j);
5219 if (!SCI_Prepare(j))
5220 return 0;
5221 j->daa_mode = SOP_PU_PULSEDIALING;
5222 break;
5223 default:
5224 break;
5225 }
5226 return 1;
5227 }
5228
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231 BYTES bytes;
5232
5233 j->flags.pstncheck = 1;
5234
5235 daa_set_mode(j, SOP_PU_SLEEP);
5236
5237 if (!SCI_Prepare(j))
5238 return 0;
5239
5240 outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242 bytes.high = 0x14;
5243 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244 if (!daa_load(&bytes, j))
5245 return 0;
5246
5247 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249 if (!daa_load(&bytes, j))
5250 return 0;
5251
5252 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254 if (!daa_load(&bytes, j))
5255 return 0;
5256
5257 if (!SCI_Prepare(j))
5258 return 0;
5259
5260 bytes.high = 0x1F;
5261 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262 if (!daa_load(&bytes, j))
5263 return 0;
5264
5265 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267 if (!daa_load(&bytes, j))
5268 return 0;
5269
5270 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272 if (!daa_load(&bytes, j))
5273 return 0;
5274
5275 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277 if (!daa_load(&bytes, j))
5278 return 0;
5279
5280 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281 bytes.low = 0x00;
5282 if (!daa_load(&bytes, j))
5283 return 0;
5284
5285 if (!SCI_Prepare(j))
5286 return 0;
5287
5288 bytes.high = 0x00;
5289 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290 if (!daa_load(&bytes, j))
5291 return 0;
5292
5293 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295 if (!daa_load(&bytes, j))
5296 return 0;
5297
5298 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300 if (!daa_load(&bytes, j))
5301 return 0;
5302
5303 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305 if (!daa_load(&bytes, j))
5306 return 0;
5307
5308 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309 bytes.low = 0x00;
5310 if (!daa_load(&bytes, j))
5311 return 0;
5312
5313 if (!SCI_Control(j, SCI_End))
5314 return 0;
5315 if (!SCI_WaitLowSCI(j))
5316 return 0;
5317
5318 bytes.high = 0x01;
5319 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320 if (!daa_load(&bytes, j))
5321 return 0;
5322
5323 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325 if (!daa_load(&bytes, j))
5326 return 0;
5327
5328 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330 if (!daa_load(&bytes, j))
5331 return 0;
5332
5333 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335 if (!daa_load(&bytes, j))
5336 return 0;
5337
5338 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339 bytes.low = 0x00;
5340 if (!daa_load(&bytes, j))
5341 return 0;
5342
5343 if (!SCI_Control(j, SCI_End))
5344 return 0;
5345 if (!SCI_WaitLowSCI(j))
5346 return 0;
5347
5348 bytes.high = 0x02;
5349 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350 if (!daa_load(&bytes, j))
5351 return 0;
5352
5353 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355 if (!daa_load(&bytes, j))
5356 return 0;
5357
5358 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360 if (!daa_load(&bytes, j))
5361 return 0;
5362
5363 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365 if (!daa_load(&bytes, j))
5366 return 0;
5367
5368 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369 bytes.low = 0x00;
5370 if (!daa_load(&bytes, j))
5371 return 0;
5372
5373 if (!SCI_Control(j, SCI_End))
5374 return 0;
5375 if (!SCI_WaitLowSCI(j))
5376 return 0;
5377
5378 bytes.high = 0x03;
5379 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380 if (!daa_load(&bytes, j))
5381 return 0;
5382
5383 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385 if (!daa_load(&bytes, j))
5386 return 0;
5387
5388 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390 if (!daa_load(&bytes, j))
5391 return 0;
5392
5393 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395 if (!daa_load(&bytes, j))
5396 return 0;
5397
5398 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399 bytes.low = 0x00;
5400 if (!daa_load(&bytes, j))
5401 return 0;
5402
5403 if (!SCI_Control(j, SCI_End))
5404 return 0;
5405 if (!SCI_WaitLowSCI(j))
5406 return 0;
5407
5408 bytes.high = 0x04;
5409 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410 if (!daa_load(&bytes, j))
5411 return 0;
5412
5413 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415 if (!daa_load(&bytes, j))
5416 return 0;
5417
5418 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420 if (!daa_load(&bytes, j))
5421 return 0;
5422
5423 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425 if (!daa_load(&bytes, j))
5426 return 0;
5427
5428 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429 bytes.low = 0x00;
5430 if (!daa_load(&bytes, j))
5431 return 0;
5432
5433 if (!SCI_Control(j, SCI_End))
5434 return 0;
5435 if (!SCI_WaitLowSCI(j))
5436 return 0;
5437
5438 bytes.high = 0x05;
5439 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440 if (!daa_load(&bytes, j))
5441 return 0;
5442
5443 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445 if (!daa_load(&bytes, j))
5446 return 0;
5447
5448 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450 if (!daa_load(&bytes, j))
5451 return 0;
5452
5453 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455 if (!daa_load(&bytes, j))
5456 return 0;
5457
5458 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459 bytes.low = 0x00;
5460 if (!daa_load(&bytes, j))
5461 return 0;
5462
5463 if (!SCI_Control(j, SCI_End))
5464 return 0;
5465 if (!SCI_WaitLowSCI(j))
5466 return 0;
5467
5468 bytes.high = 0x06;
5469 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470 if (!daa_load(&bytes, j))
5471 return 0;
5472
5473 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475 if (!daa_load(&bytes, j))
5476 return 0;
5477
5478 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480 if (!daa_load(&bytes, j))
5481 return 0;
5482
5483 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485 if (!daa_load(&bytes, j))
5486 return 0;
5487
5488 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489 bytes.low = 0x00;
5490 if (!daa_load(&bytes, j))
5491 return 0;
5492
5493 if (!SCI_Control(j, SCI_End))
5494 return 0;
5495 if (!SCI_WaitLowSCI(j))
5496 return 0;
5497
5498 bytes.high = 0x07;
5499 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500 if (!daa_load(&bytes, j))
5501 return 0;
5502
5503 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505 if (!daa_load(&bytes, j))
5506 return 0;
5507
5508 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510 if (!daa_load(&bytes, j))
5511 return 0;
5512
5513 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515 if (!daa_load(&bytes, j))
5516 return 0;
5517
5518 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519 bytes.low = 0x00;
5520 if (!daa_load(&bytes, j))
5521 return 0;
5522
5523 if (!SCI_Control(j, SCI_End))
5524 return 0;
5525 if (!SCI_WaitLowSCI(j))
5526 return 0;
5527
5528 bytes.high = 0x08;
5529 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530 if (!daa_load(&bytes, j))
5531 return 0;
5532
5533 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535 if (!daa_load(&bytes, j))
5536 return 0;
5537
5538 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540 if (!daa_load(&bytes, j))
5541 return 0;
5542
5543 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545 if (!daa_load(&bytes, j))
5546 return 0;
5547
5548 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549 bytes.low = 0x00;
5550 if (!daa_load(&bytes, j))
5551 return 0;
5552
5553 if (!SCI_Control(j, SCI_End))
5554 return 0;
5555 if (!SCI_WaitLowSCI(j))
5556 return 0;
5557
5558 bytes.high = 0x09;
5559 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560 if (!daa_load(&bytes, j))
5561 return 0;
5562
5563 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565 if (!daa_load(&bytes, j))
5566 return 0;
5567
5568 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569 bytes.low = 0x00;
5570 if (!daa_load(&bytes, j))
5571 return 0;
5572
5573 if (!SCI_Control(j, SCI_End))
5574 return 0;
5575 if (!SCI_WaitLowSCI(j))
5576 return 0;
5577
5578 bytes.high = 0x0A;
5579 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580 if (!daa_load(&bytes, j))
5581 return 0;
5582
5583 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585 if (!daa_load(&bytes, j))
5586 return 0;
5587
5588 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589 bytes.low = 0x00;
5590 if (!daa_load(&bytes, j))
5591 return 0;
5592
5593 if (!SCI_Control(j, SCI_End))
5594 return 0;
5595 if (!SCI_WaitLowSCI(j))
5596 return 0;
5597
5598 bytes.high = 0x0B;
5599 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600 if (!daa_load(&bytes, j))
5601 return 0;
5602
5603 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605 if (!daa_load(&bytes, j))
5606 return 0;
5607
5608 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609 bytes.low = 0x00;
5610 if (!daa_load(&bytes, j))
5611 return 0;
5612
5613 if (!SCI_Control(j, SCI_End))
5614 return 0;
5615 if (!SCI_WaitLowSCI(j))
5616 return 0;
5617
5618 bytes.high = 0x0C;
5619 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620 if (!daa_load(&bytes, j))
5621 return 0;
5622
5623 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625 if (!daa_load(&bytes, j))
5626 return 0;
5627
5628 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629 bytes.low = 0x00;
5630 if (!daa_load(&bytes, j))
5631 return 0;
5632
5633 if (!SCI_Control(j, SCI_End))
5634 return 0;
5635 if (!SCI_WaitLowSCI(j))
5636 return 0;
5637
5638 bytes.high = 0x0D;
5639 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640 if (!daa_load(&bytes, j))
5641 return 0;
5642
5643 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645 if (!daa_load(&bytes, j))
5646 return 0;
5647
5648 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649 bytes.low = 0x00;
5650 if (!daa_load(&bytes, j))
5651 return 0;
5652
5653 if (!SCI_Control(j, SCI_End))
5654 return 0;
5655 if (!SCI_WaitLowSCI(j))
5656 return 0;
5657
5658 bytes.high = 0x0E;
5659 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660 if (!daa_load(&bytes, j))
5661 return 0;
5662
5663 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665 if (!daa_load(&bytes, j))
5666 return 0;
5667
5668 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670 if (!daa_load(&bytes, j))
5671 return 0;
5672
5673 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675 if (!daa_load(&bytes, j))
5676 return 0;
5677
5678 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679 bytes.low = 0x00;
5680 if (!daa_load(&bytes, j))
5681 return 0;
5682
5683 if (!SCI_Control(j, SCI_End))
5684 return 0;
5685 if (!SCI_WaitLowSCI(j))
5686 return 0;
5687
5688 bytes.high = 0x0F;
5689 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690 if (!daa_load(&bytes, j))
5691 return 0;
5692
5693 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695 if (!daa_load(&bytes, j))
5696 return 0;
5697
5698 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700 if (!daa_load(&bytes, j))
5701 return 0;
5702
5703 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705 if (!daa_load(&bytes, j))
5706 return 0;
5707
5708 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709 bytes.low = 0x00;
5710 if (!daa_load(&bytes, j))
5711 return 0;
5712
5713 udelay(32);
5714 j->pld_scrr.byte = inb_p(j->XILINXbase);
5715 if (!SCI_Control(j, SCI_End))
5716 return 0;
5717
5718 outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720 if (ixjdebug & 0x0002)
5721 printk("DAA Coefficients Loaded\n");
5722
5723 j->flags.pstncheck = 0;
5724 return 1;
5725 }
5726
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729 j->tone_off_time = arg;
5730 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5731
5732 return -1;
5733 if (ixj_WriteDSPCommand(arg, j))
5734 return -1;
5735 return 0;
5736 }
5737
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5741
5742 return -1;
5743 return 0;
5744 }
5745
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5749
5750 return -1;
5751 return 0;
5752 }
5753
5754 static void ixj_busytone(IXJ *j)
5755 {
5756 j->flags.ringback = 0;
5757 j->flags.dialtone = 0;
5758 j->flags.busytone = 1;
5759 ixj_set_tone_on(0x07D0, j);
5760 ixj_set_tone_off(0x07D0, j);
5761 ixj_play_tone(j, 27);
5762 }
5763
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766 j->flags.ringback = 0;
5767 j->flags.dialtone = 1;
5768 j->flags.busytone = 0;
5769 if (j->dsp.low == 0x20) {
5770 return;
5771 } else {
5772 ixj_set_tone_on(0xFFFF, j);
5773 ixj_set_tone_off(0x0000, j);
5774 ixj_play_tone(j, 25);
5775 }
5776 }
5777
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780 if(j->tone_state || j->tone_cadence_state)
5781 {
5782 j->flags.dialtone = 0;
5783 j->flags.busytone = 0;
5784 j->flags.ringback = 0;
5785 ixj_set_tone_on(0x0001, j);
5786 ixj_set_tone_off(0x0000, j);
5787 ixj_play_tone(j, 0);
5788 j->tone_state = j->tone_cadence_state = 0;
5789 if (j->cadence_t) {
5790 kfree(j->cadence_t->ce);
5791 kfree(j->cadence_t);
5792 j->cadence_t = NULL;
5793 }
5794 }
5795 if (j->play_mode == -1 && j->rec_mode == -1)
5796 idle(j);
5797 if (j->play_mode != -1 && j->dsp.low == 0x20)
5798 ixj_play_start(j);
5799 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800 ixj_record_start(j);
5801 }
5802
5803 static void ixj_ringback(IXJ *j)
5804 {
5805 j->flags.busytone = 0;
5806 j->flags.dialtone = 0;
5807 j->flags.ringback = 1;
5808 ixj_set_tone_on(0x0FA0, j);
5809 ixj_set_tone_off(0x2EE0, j);
5810 ixj_play_tone(j, 26);
5811 }
5812
5813 static void ixj_testram(IXJ *j)
5814 {
5815 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820 ixj_cadence *lcp;
5821 IXJ_CADENCE_ELEMENT __user *cep;
5822 IXJ_CADENCE_ELEMENT *lcep;
5823 IXJ_TONE ti;
5824 int err;
5825
5826 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827 if (lcp == NULL)
5828 return -ENOMEM;
5829
5830 err = -EFAULT;
5831 if (copy_from_user(&lcp->elements_used,
5832 &cp->elements_used, sizeof(int)))
5833 goto out;
5834 if (copy_from_user(&lcp->termination,
5835 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836 goto out;
5837 if (get_user(cep, &cp->ce))
5838 goto out;
5839
5840 err = -EINVAL;
5841 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842 goto out;
5843
5844 err = -ENOMEM;
5845 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846 if (!lcep)
5847 goto out;
5848
5849 err = -EFAULT;
5850 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851 goto out1;
5852
5853 if (j->cadence_t) {
5854 kfree(j->cadence_t->ce);
5855 kfree(j->cadence_t);
5856 }
5857 lcp->ce = (void *) lcep;
5858 j->cadence_t = lcp;
5859 j->tone_cadence_state = 0;
5860 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868 ixj_init_tone(j, &ti);
5869 }
5870 ixj_play_tone(j, lcp->ce[0].index);
5871 return 1;
5872 out1:
5873 kfree(lcep);
5874 out:
5875 kfree(lcp);
5876 return err;
5877 }
5878
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881 IXJ_FILTER_CADENCE *lcp;
5882 lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
5883 if (IS_ERR(lcp)) {
5884 if(ixjdebug & 0x0001) {
5885 printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
5886 }
5887 return PTR_ERR(lcp);
5888 }
5889 if (lcp->filter > 5) {
5890 if(ixjdebug & 0x0001) {
5891 printk(KERN_INFO "Cadence out of range\n");
5892 }
5893 kfree(lcp);
5894 return -1;
5895 }
5896 j->cadence_f[lcp->filter].state = 0;
5897 j->cadence_f[lcp->filter].enable = lcp->enable;
5898 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5899 j->cadence_f[lcp->filter].on1 = lcp->on1;
5900 j->cadence_f[lcp->filter].on1min = 0;
5901 j->cadence_f[lcp->filter].on1max = 0;
5902 j->cadence_f[lcp->filter].off1 = lcp->off1;
5903 j->cadence_f[lcp->filter].off1min = 0;
5904 j->cadence_f[lcp->filter].off1max = 0;
5905 j->cadence_f[lcp->filter].on2 = lcp->on2;
5906 j->cadence_f[lcp->filter].on2min = 0;
5907 j->cadence_f[lcp->filter].on2max = 0;
5908 j->cadence_f[lcp->filter].off2 = lcp->off2;
5909 j->cadence_f[lcp->filter].off2min = 0;
5910 j->cadence_f[lcp->filter].off2max = 0;
5911 j->cadence_f[lcp->filter].on3 = lcp->on3;
5912 j->cadence_f[lcp->filter].on3min = 0;
5913 j->cadence_f[lcp->filter].on3max = 0;
5914 j->cadence_f[lcp->filter].off3 = lcp->off3;
5915 j->cadence_f[lcp->filter].off3min = 0;
5916 j->cadence_f[lcp->filter].off3max = 0;
5917 if(ixjdebug & 0x0002) {
5918 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5919 }
5920 kfree(lcp);
5921 return 0;
5922 }
5923
5924 static void add_caps(IXJ *j)
5925 {
5926 j->caps = 0;
5927 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5928 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5929 j->caplist[j->caps].captype = vendor;
5930 j->caplist[j->caps].handle = j->caps++;
5931 j->caplist[j->caps].captype = device;
5932 switch (j->cardtype) {
5933 case QTI_PHONEJACK:
5934 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5935 break;
5936 case QTI_LINEJACK:
5937 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5938 break;
5939 case QTI_PHONEJACK_LITE:
5940 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5941 break;
5942 case QTI_PHONEJACK_PCI:
5943 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5944 break;
5945 case QTI_PHONECARD:
5946 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5947 break;
5948 }
5949 j->caplist[j->caps].cap = j->cardtype;
5950 j->caplist[j->caps].handle = j->caps++;
5951 strcpy(j->caplist[j->caps].desc, "POTS");
5952 j->caplist[j->caps].captype = port;
5953 j->caplist[j->caps].cap = pots;
5954 j->caplist[j->caps].handle = j->caps++;
5955
5956 /* add devices that can do speaker/mic */
5957 switch (j->cardtype) {
5958 case QTI_PHONEJACK:
5959 case QTI_LINEJACK:
5960 case QTI_PHONEJACK_PCI:
5961 case QTI_PHONECARD:
5962 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5963 j->caplist[j->caps].captype = port;
5964 j->caplist[j->caps].cap = speaker;
5965 j->caplist[j->caps].handle = j->caps++;
5966 default:
5967 break;
5968 }
5969
5970 /* add devices that can do handset */
5971 switch (j->cardtype) {
5972 case QTI_PHONEJACK:
5973 strcpy(j->caplist[j->caps].desc, "HANDSET");
5974 j->caplist[j->caps].captype = port;
5975 j->caplist[j->caps].cap = handset;
5976 j->caplist[j->caps].handle = j->caps++;
5977 break;
5978 default:
5979 break;
5980 }
5981
5982 /* add devices that can do PSTN */
5983 switch (j->cardtype) {
5984 case QTI_LINEJACK:
5985 strcpy(j->caplist[j->caps].desc, "PSTN");
5986 j->caplist[j->caps].captype = port;
5987 j->caplist[j->caps].cap = pstn;
5988 j->caplist[j->caps].handle = j->caps++;
5989 break;
5990 default:
5991 break;
5992 }
5993
5994 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5995 strcpy(j->caplist[j->caps].desc, "ULAW");
5996 j->caplist[j->caps].captype = codec;
5997 j->caplist[j->caps].cap = ULAW;
5998 j->caplist[j->caps].handle = j->caps++;
5999
6000 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6001 j->caplist[j->caps].captype = codec;
6002 j->caplist[j->caps].cap = LINEAR16;
6003 j->caplist[j->caps].handle = j->caps++;
6004
6005 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6006 j->caplist[j->caps].captype = codec;
6007 j->caplist[j->caps].cap = LINEAR8;
6008 j->caplist[j->caps].handle = j->caps++;
6009
6010 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6011 j->caplist[j->caps].captype = codec;
6012 j->caplist[j->caps].cap = WSS;
6013 j->caplist[j->caps].handle = j->caps++;
6014
6015 /* software ALAW codec, made from ULAW */
6016 strcpy(j->caplist[j->caps].desc, "ALAW");
6017 j->caplist[j->caps].captype = codec;
6018 j->caplist[j->caps].cap = ALAW;
6019 j->caplist[j->caps].handle = j->caps++;
6020
6021 /* version 12 of the 8020 does the following codecs in a broken way */
6022 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6023 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6024 j->caplist[j->caps].captype = codec;
6025 j->caplist[j->caps].cap = G723_63;
6026 j->caplist[j->caps].handle = j->caps++;
6027
6028 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6029 j->caplist[j->caps].captype = codec;
6030 j->caplist[j->caps].cap = G723_53;
6031 j->caplist[j->caps].handle = j->caps++;
6032
6033 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6034 j->caplist[j->caps].captype = codec;
6035 j->caplist[j->caps].cap = TS48;
6036 j->caplist[j->caps].handle = j->caps++;
6037
6038 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6039 j->caplist[j->caps].captype = codec;
6040 j->caplist[j->caps].cap = TS41;
6041 j->caplist[j->caps].handle = j->caps++;
6042 }
6043
6044 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6045 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6046 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6047 j->caplist[j->caps].captype = codec;
6048 j->caplist[j->caps].cap = TS85;
6049 j->caplist[j->caps].handle = j->caps++;
6050 }
6051
6052 /* 8021 chips can do G728 */
6053 if (j->dsp.low == 0x21) {
6054 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6055 j->caplist[j->caps].captype = codec;
6056 j->caplist[j->caps].cap = G728;
6057 j->caplist[j->caps].handle = j->caps++;
6058 }
6059
6060 /* 8021/8022 chips can do G729 if loaded */
6061 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6062 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6063 j->caplist[j->caps].captype = codec;
6064 j->caplist[j->caps].cap = G729;
6065 j->caplist[j->caps].handle = j->caps++;
6066 }
6067 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6068 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6069 j->caplist[j->caps].captype = codec;
6070 j->caplist[j->caps].cap = G729B;
6071 j->caplist[j->caps].handle = j->caps++;
6072 }
6073 }
6074
6075 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6076 {
6077 int cnt;
6078 int retval = 0;
6079 for (cnt = 0; cnt < j->caps; cnt++) {
6080 if (pcreq->captype == j->caplist[cnt].captype
6081 && pcreq->cap == j->caplist[cnt].cap) {
6082 retval = 1;
6083 break;
6084 }
6085 }
6086 return retval;
6087 }
6088
6089 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6090 {
6091 IXJ_TONE ti;
6092 IXJ_FILTER jf;
6093 IXJ_FILTER_RAW jfr;
6094 void __user *argp = (void __user *)arg;
6095 struct inode *inode = file_p->f_path.dentry->d_inode;
6096 unsigned int minor = iminor(inode);
6097 unsigned int raise, mant;
6098 int board = NUM(inode);
6099
6100 IXJ *j = get_ixj(NUM(inode));
6101
6102 int retval = 0;
6103
6104 /*
6105 * Set up locks to ensure that only one process is talking to the DSP at a time.
6106 * This is necessary to keep the DSP from locking up.
6107 */
6108 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6109 schedule_timeout_interruptible(1);
6110 if (ixjdebug & 0x0040)
6111 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6112 if (minor >= IXJMAX) {
6113 clear_bit(board, &j->busyflags);
6114 return -ENODEV;
6115 }
6116 /*
6117 * Check ioctls only root can use.
6118 */
6119 if (!capable(CAP_SYS_ADMIN)) {
6120 switch (cmd) {
6121 case IXJCTL_TESTRAM:
6122 case IXJCTL_HZ:
6123 retval = -EPERM;
6124 }
6125 }
6126 switch (cmd) {
6127 case IXJCTL_TESTRAM:
6128 ixj_testram(j);
6129 retval = (j->ssr.high << 8) + j->ssr.low;
6130 break;
6131 case IXJCTL_CARDTYPE:
6132 retval = j->cardtype;
6133 break;
6134 case IXJCTL_SERIAL:
6135 retval = j->serial;
6136 break;
6137 case IXJCTL_VERSION:
6138 {
6139 char arg_str[100];
6140 snprintf(arg_str, sizeof(arg_str),
6141 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6142 IXJ_VER_MINOR, IXJ_BLD_VER);
6143 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6144 retval = -EFAULT;
6145 }
6146 break;
6147 case PHONE_RING_CADENCE:
6148 j->ring_cadence = arg;
6149 break;
6150 case IXJCTL_CIDCW:
6151 if(arg) {
6152 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6153 retval = -EFAULT;
6154 break;
6155 }
6156 } else {
6157 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6158 }
6159 ixj_write_cidcw(j);
6160 break;
6161 /* Binary compatbility */
6162 case OLD_PHONE_RING_START:
6163 arg = 0;
6164 /* Fall through */
6165 case PHONE_RING_START:
6166 if(arg) {
6167 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6168 retval = -EFAULT;
6169 break;
6170 }
6171 ixj_write_cid(j);
6172 } else {
6173 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6174 }
6175 ixj_ring_start(j);
6176 break;
6177 case PHONE_RING_STOP:
6178 j->flags.cringing = 0;
6179 if(j->cadence_f[5].enable) {
6180 j->cadence_f[5].state = 0;
6181 }
6182 ixj_ring_off(j);
6183 break;
6184 case PHONE_RING:
6185 retval = ixj_ring(j);
6186 break;
6187 case PHONE_EXCEPTION:
6188 retval = j->ex.bytes;
6189 if(j->ex.bits.flash) {
6190 j->flash_end = 0;
6191 j->ex.bits.flash = 0;
6192 }
6193 j->ex.bits.pstn_ring = 0;
6194 j->ex.bits.caller_id = 0;
6195 j->ex.bits.pstn_wink = 0;
6196 j->ex.bits.f0 = 0;
6197 j->ex.bits.f1 = 0;
6198 j->ex.bits.f2 = 0;
6199 j->ex.bits.f3 = 0;
6200 j->ex.bits.fc0 = 0;
6201 j->ex.bits.fc1 = 0;
6202 j->ex.bits.fc2 = 0;
6203 j->ex.bits.fc3 = 0;
6204 j->ex.bits.reserved = 0;
6205 break;
6206 case PHONE_HOOKSTATE:
6207 j->ex.bits.hookstate = 0;
6208 retval = j->hookstate; //j->r_hook;
6209 break;
6210 case IXJCTL_SET_LED:
6211 LED_SetState(arg, j);
6212 break;
6213 case PHONE_FRAME:
6214 retval = set_base_frame(j, arg);
6215 break;
6216 case PHONE_REC_CODEC:
6217 retval = set_rec_codec(j, arg);
6218 break;
6219 case PHONE_VAD:
6220 ixj_vad(j, arg);
6221 break;
6222 case PHONE_REC_START:
6223 ixj_record_start(j);
6224 break;
6225 case PHONE_REC_STOP:
6226 ixj_record_stop(j);
6227 break;
6228 case PHONE_REC_DEPTH:
6229 set_rec_depth(j, arg);
6230 break;
6231 case PHONE_REC_VOLUME:
6232 if(arg == -1) {
6233 retval = get_rec_volume(j);
6234 }
6235 else {
6236 set_rec_volume(j, arg);
6237 retval = arg;
6238 }
6239 break;
6240 case PHONE_REC_VOLUME_LINEAR:
6241 if(arg == -1) {
6242 retval = get_rec_volume_linear(j);
6243 }
6244 else {
6245 set_rec_volume_linear(j, arg);
6246 retval = arg;
6247 }
6248 break;
6249 case IXJCTL_DTMF_PRESCALE:
6250 if(arg == -1) {
6251 retval = get_dtmf_prescale(j);
6252 }
6253 else {
6254 set_dtmf_prescale(j, arg);
6255 retval = arg;
6256 }
6257 break;
6258 case PHONE_REC_LEVEL:
6259 retval = get_rec_level(j);
6260 break;
6261 case IXJCTL_SC_RXG:
6262 retval = ixj_siadc(j, arg);
6263 break;
6264 case IXJCTL_SC_TXG:
6265 retval = ixj_sidac(j, arg);
6266 break;
6267 case IXJCTL_AEC_START:
6268 ixj_aec_start(j, arg);
6269 break;
6270 case IXJCTL_AEC_STOP:
6271 aec_stop(j);
6272 break;
6273 case IXJCTL_AEC_GET_LEVEL:
6274 retval = j->aec_level;
6275 break;
6276 case PHONE_PLAY_CODEC:
6277 retval = set_play_codec(j, arg);
6278 break;
6279 case PHONE_PLAY_START:
6280 retval = ixj_play_start(j);
6281 break;
6282 case PHONE_PLAY_STOP:
6283 ixj_play_stop(j);
6284 break;
6285 case PHONE_PLAY_DEPTH:
6286 set_play_depth(j, arg);
6287 break;
6288 case PHONE_PLAY_VOLUME:
6289 if(arg == -1) {
6290 retval = get_play_volume(j);
6291 }
6292 else {
6293 set_play_volume(j, arg);
6294 retval = arg;
6295 }
6296 break;
6297 case PHONE_PLAY_VOLUME_LINEAR:
6298 if(arg == -1) {
6299 retval = get_play_volume_linear(j);
6300 }
6301 else {
6302 set_play_volume_linear(j, arg);
6303 retval = arg;
6304 }
6305 break;
6306 case PHONE_PLAY_LEVEL:
6307 retval = get_play_level(j);
6308 break;
6309 case IXJCTL_DSP_TYPE:
6310 retval = (j->dsp.high << 8) + j->dsp.low;
6311 break;
6312 case IXJCTL_DSP_VERSION:
6313 retval = (j->ver.high << 8) + j->ver.low;
6314 break;
6315 case IXJCTL_HZ:
6316 hertz = arg;
6317 break;
6318 case IXJCTL_RATE:
6319 if (arg > hertz)
6320 retval = -1;
6321 else
6322 samplerate = arg;
6323 break;
6324 case IXJCTL_DRYBUFFER_READ:
6325 put_user(j->drybuffer, (unsigned long __user *) argp);
6326 break;
6327 case IXJCTL_DRYBUFFER_CLEAR:
6328 j->drybuffer = 0;
6329 break;
6330 case IXJCTL_FRAMES_READ:
6331 put_user(j->framesread, (unsigned long __user *) argp);
6332 break;
6333 case IXJCTL_FRAMES_WRITTEN:
6334 put_user(j->frameswritten, (unsigned long __user *) argp);
6335 break;
6336 case IXJCTL_READ_WAIT:
6337 put_user(j->read_wait, (unsigned long __user *) argp);
6338 break;
6339 case IXJCTL_WRITE_WAIT:
6340 put_user(j->write_wait, (unsigned long __user *) argp);
6341 break;
6342 case PHONE_MAXRINGS:
6343 j->maxrings = arg;
6344 break;
6345 case PHONE_SET_TONE_ON_TIME:
6346 ixj_set_tone_on(arg, j);
6347 break;
6348 case PHONE_SET_TONE_OFF_TIME:
6349 ixj_set_tone_off(arg, j);
6350 break;
6351 case PHONE_GET_TONE_ON_TIME:
6352 if (ixj_get_tone_on(j)) {
6353 retval = -1;
6354 } else {
6355 retval = (j->ssr.high << 8) + j->ssr.low;
6356 }
6357 break;
6358 case PHONE_GET_TONE_OFF_TIME:
6359 if (ixj_get_tone_off(j)) {
6360 retval = -1;
6361 } else {
6362 retval = (j->ssr.high << 8) + j->ssr.low;
6363 }
6364 break;
6365 case PHONE_PLAY_TONE:
6366 if (!j->tone_state)
6367 retval = ixj_play_tone(j, arg);
6368 else
6369 retval = -1;
6370 break;
6371 case PHONE_GET_TONE_STATE:
6372 retval = j->tone_state;
6373 break;
6374 case PHONE_DTMF_READY:
6375 retval = j->ex.bits.dtmf_ready;
6376 break;
6377 case PHONE_GET_DTMF:
6378 if (ixj_hookstate(j)) {
6379 if (j->dtmf_rp != j->dtmf_wp) {
6380 retval = j->dtmfbuffer[j->dtmf_rp];
6381 j->dtmf_rp++;
6382 if (j->dtmf_rp == 79)
6383 j->dtmf_rp = 0;
6384 if (j->dtmf_rp == j->dtmf_wp) {
6385 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6386 }
6387 }
6388 }
6389 break;
6390 case PHONE_GET_DTMF_ASCII:
6391 if (ixj_hookstate(j)) {
6392 if (j->dtmf_rp != j->dtmf_wp) {
6393 switch (j->dtmfbuffer[j->dtmf_rp]) {
6394 case 10:
6395 retval = 42; /* '*'; */
6396
6397 break;
6398 case 11:
6399 retval = 48; /*'0'; */
6400
6401 break;
6402 case 12:
6403 retval = 35; /*'#'; */
6404
6405 break;
6406 case 28:
6407 retval = 65; /*'A'; */
6408
6409 break;
6410 case 29:
6411 retval = 66; /*'B'; */
6412
6413 break;
6414 case 30:
6415 retval = 67; /*'C'; */
6416
6417 break;
6418 case 31:
6419 retval = 68; /*'D'; */
6420
6421 break;
6422 default:
6423 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6424 break;
6425 }
6426 j->dtmf_rp++;
6427 if (j->dtmf_rp == 79)
6428 j->dtmf_rp = 0;
6429 if(j->dtmf_rp == j->dtmf_wp)
6430 {
6431 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6432 }
6433 }
6434 }
6435 break;
6436 case PHONE_DTMF_OOB:
6437 j->flags.dtmf_oob = arg;
6438 break;
6439 case PHONE_DIALTONE:
6440 ixj_dialtone(j);
6441 break;
6442 case PHONE_BUSY:
6443 ixj_busytone(j);
6444 break;
6445 case PHONE_RINGBACK:
6446 ixj_ringback(j);
6447 break;
6448 case PHONE_WINK:
6449 if(j->cardtype == QTI_PHONEJACK)
6450 retval = -1;
6451 else
6452 retval = ixj_wink(j);
6453 break;
6454 case PHONE_CPT_STOP:
6455 ixj_cpt_stop(j);
6456 break;
6457 case PHONE_QUERY_CODEC:
6458 {
6459 struct phone_codec_data pd;
6460 int val;
6461 int proto_size[] = {
6462 -1,
6463 12, 10, 16, 9, 8, 48, 5,
6464 40, 40, 80, 40, 40, 6
6465 };
6466 if(copy_from_user(&pd, argp, sizeof(pd))) {
6467 retval = -EFAULT;
6468 break;
6469 }
6470 if(pd.type<1 || pd.type>13) {
6471 retval = -EPROTONOSUPPORT;
6472 break;
6473 }
6474 if(pd.type<G729)
6475 val=proto_size[pd.type];
6476 else switch(j->baseframe.low)
6477 {
6478 case 0xA0:val=2*proto_size[pd.type];break;
6479 case 0x50:val=proto_size[pd.type];break;
6480 default:val=proto_size[pd.type]*3;break;
6481 }
6482 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6483 if(copy_to_user(argp, &pd, sizeof(pd)))
6484 retval = -EFAULT;
6485 break;
6486 }
6487 case IXJCTL_DSP_IDLE:
6488 idle(j);
6489 break;
6490 case IXJCTL_MIXER:
6491 if ((arg & 0xff) == 0xff)
6492 retval = ixj_get_mixer(arg, j);
6493 else
6494 ixj_mixer(arg, j);
6495 break;
6496 case IXJCTL_DAA_COEFF_SET:
6497 switch (arg) {
6498 case DAA_US:
6499 DAA_Coeff_US(j);
6500 retval = ixj_daa_write(j);
6501 break;
6502 case DAA_UK:
6503 DAA_Coeff_UK(j);
6504 retval = ixj_daa_write(j);
6505 break;
6506 case DAA_FRANCE:
6507 DAA_Coeff_France(j);
6508 retval = ixj_daa_write(j);
6509 break;
6510 case DAA_GERMANY:
6511 DAA_Coeff_Germany(j);
6512 retval = ixj_daa_write(j);
6513 break;
6514 case DAA_AUSTRALIA:
6515 DAA_Coeff_Australia(j);
6516 retval = ixj_daa_write(j);
6517 break;
6518 case DAA_JAPAN:
6519 DAA_Coeff_Japan(j);
6520 retval = ixj_daa_write(j);
6521 break;
6522 default:
6523 retval = 1;
6524 break;
6525 }
6526 break;
6527 case IXJCTL_DAA_AGAIN:
6528 ixj_daa_cr4(j, arg | 0x02);
6529 break;
6530 case IXJCTL_PSTN_LINETEST:
6531 retval = ixj_linetest(j);
6532 break;
6533 case IXJCTL_VMWI:
6534 ixj_write_vmwi(j, arg);
6535 break;
6536 case IXJCTL_CID:
6537 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6538 retval = -EFAULT;
6539 j->ex.bits.caller_id = 0;
6540 break;
6541 case IXJCTL_WINK_DURATION:
6542 j->winktime = arg;
6543 break;
6544 case IXJCTL_PORT:
6545 if (arg)
6546 retval = ixj_set_port(j, arg);
6547 else
6548 retval = j->port;
6549 break;
6550 case IXJCTL_POTS_PSTN:
6551 retval = ixj_set_pots(j, arg);
6552 break;
6553 case PHONE_CAPABILITIES:
6554 add_caps(j);
6555 retval = j->caps;
6556 break;
6557 case PHONE_CAPABILITIES_LIST:
6558 add_caps(j);
6559 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6560 retval = -EFAULT;
6561 break;
6562 case PHONE_CAPABILITIES_CHECK:
6563 {
6564 struct phone_capability cap;
6565 if (copy_from_user(&cap, argp, sizeof(cap)))
6566 retval = -EFAULT;
6567 else {
6568 add_caps(j);
6569 retval = capabilities_check(j, &cap);
6570 }
6571 }
6572 break;
6573 case PHONE_PSTN_SET_STATE:
6574 daa_set_mode(j, arg);
6575 break;
6576 case PHONE_PSTN_GET_STATE:
6577 retval = j->daa_mode;
6578 j->ex.bits.pstn_ring = 0;
6579 break;
6580 case IXJCTL_SET_FILTER:
6581 if (copy_from_user(&jf, argp, sizeof(jf)))
6582 retval = -EFAULT;
6583 retval = ixj_init_filter(j, &jf);
6584 break;
6585 case IXJCTL_SET_FILTER_RAW:
6586 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6587 retval = -EFAULT;
6588 else
6589 retval = ixj_init_filter_raw(j, &jfr);
6590 break;
6591 case IXJCTL_GET_FILTER_HIST:
6592 if(arg<0||arg>3)
6593 retval = -EINVAL;
6594 else
6595 retval = j->filter_hist[arg];
6596 break;
6597 case IXJCTL_INIT_TONE:
6598 if (copy_from_user(&ti, argp, sizeof(ti)))
6599 retval = -EFAULT;
6600 else
6601 retval = ixj_init_tone(j, &ti);
6602 break;
6603 case IXJCTL_TONE_CADENCE:
6604 retval = ixj_build_cadence(j, argp);
6605 break;
6606 case IXJCTL_FILTER_CADENCE:
6607 retval = ixj_build_filter_cadence(j, argp);
6608 break;
6609 case IXJCTL_SIGCTL:
6610 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6611 retval = -EFAULT;
6612 break;
6613 }
6614 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6615 if(j->sigdef.event < 33) {
6616 raise = 1;
6617 for(mant = 0; mant < j->sigdef.event; mant++){
6618 raise *= 2;
6619 }
6620 if(j->sigdef.signal)
6621 j->ex_sig.bytes |= raise;
6622 else
6623 j->ex_sig.bytes &= (raise^0xffff);
6624 }
6625 break;
6626 case IXJCTL_INTERCOM_STOP:
6627 if(arg < 0 || arg >= IXJMAX)
6628 return -EINVAL;
6629 j->intercom = -1;
6630 ixj_record_stop(j);
6631 ixj_play_stop(j);
6632 idle(j);
6633 get_ixj(arg)->intercom = -1;
6634 ixj_record_stop(get_ixj(arg));
6635 ixj_play_stop(get_ixj(arg));
6636 idle(get_ixj(arg));
6637 break;
6638 case IXJCTL_INTERCOM_START:
6639 if(arg < 0 || arg >= IXJMAX)
6640 return -EINVAL;
6641 j->intercom = arg;
6642 ixj_record_start(j);
6643 ixj_play_start(j);
6644 get_ixj(arg)->intercom = board;
6645 ixj_play_start(get_ixj(arg));
6646 ixj_record_start(get_ixj(arg));
6647 break;
6648 }
6649 if (ixjdebug & 0x0040)
6650 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6651 clear_bit(board, &j->busyflags);
6652 return retval;
6653 }
6654
6655 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6656 {
6657 long ret;
6658 lock_kernel();
6659 ret = do_ixj_ioctl(file_p, cmd, arg);
6660 unlock_kernel();
6661 return ret;
6662 }
6663
6664 static int ixj_fasync(int fd, struct file *file_p, int mode)
6665 {
6666 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6667
6668 return fasync_helper(fd, file_p, mode, &j->async_queue);
6669 }
6670
6671 static const struct file_operations ixj_fops =
6672 {
6673 .owner = THIS_MODULE,
6674 .read = ixj_enhanced_read,
6675 .write = ixj_enhanced_write,
6676 .poll = ixj_poll,
6677 .unlocked_ioctl = ixj_ioctl,
6678 .release = ixj_release,
6679 .fasync = ixj_fasync
6680 };
6681
6682 static int ixj_linetest(IXJ *j)
6683 {
6684 j->flags.pstncheck = 1; /* Testing */
6685 j->flags.pstn_present = 0; /* Assume the line is not there */
6686
6687 daa_int_read(j); /*Clear DAA Interrupt flags */
6688 /* */
6689 /* Hold all relays in the normally de-energized position. */
6690 /* */
6691
6692 j->pld_slicw.bits.rly1 = 0;
6693 j->pld_slicw.bits.rly2 = 0;
6694 j->pld_slicw.bits.rly3 = 0;
6695 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6696 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6697
6698 outb_p(j->pld_scrw.byte, j->XILINXbase);
6699 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6700 if (j->pld_slicr.bits.potspstn) {
6701 j->flags.pots_pstn = 1;
6702 j->flags.pots_correct = 0;
6703 LED_SetState(0x4, j);
6704 } else {
6705 j->flags.pots_pstn = 0;
6706 j->pld_slicw.bits.rly1 = 0;
6707 j->pld_slicw.bits.rly2 = 0;
6708 j->pld_slicw.bits.rly3 = 1;
6709 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6710 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6711
6712 outb_p(j->pld_scrw.byte, j->XILINXbase);
6713 daa_set_mode(j, SOP_PU_CONVERSATION);
6714 msleep(1000);
6715 daa_int_read(j);
6716 daa_set_mode(j, SOP_PU_RESET);
6717 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6718 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6719 LED_SetState(0x4, j);
6720 j->pld_slicw.bits.rly3 = 0;
6721 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6722 } else {
6723 j->flags.pots_correct = 1;
6724 LED_SetState(0x8, j);
6725 j->pld_slicw.bits.rly1 = 1;
6726 j->pld_slicw.bits.rly2 = 0;
6727 j->pld_slicw.bits.rly3 = 0;
6728 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6729 }
6730 }
6731 j->pld_slicw.bits.rly3 = 0;
6732 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6733 daa_set_mode(j, SOP_PU_CONVERSATION);
6734 msleep(1000);
6735 daa_int_read(j);
6736 daa_set_mode(j, SOP_PU_RESET);
6737 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6738 j->pstn_sleeptil = jiffies + (hertz / 4);
6739 j->flags.pstn_present = 1;
6740 } else {
6741 j->flags.pstn_present = 0;
6742 }
6743 if (j->flags.pstn_present) {
6744 if (j->flags.pots_correct) {
6745 LED_SetState(0xA, j);
6746 } else {
6747 LED_SetState(0x6, j);
6748 }
6749 } else {
6750 if (j->flags.pots_correct) {
6751 LED_SetState(0x9, j);
6752 } else {
6753 LED_SetState(0x5, j);
6754 }
6755 }
6756 j->flags.pstncheck = 0; /* Testing */
6757 return j->flags.pstn_present;
6758 }
6759
6760 static int ixj_selfprobe(IXJ *j)
6761 {
6762 unsigned short cmd;
6763 int cnt;
6764 BYTES bytes;
6765
6766 init_waitqueue_head(&j->poll_q);
6767 init_waitqueue_head(&j->read_q);
6768 init_waitqueue_head(&j->write_q);
6769
6770 while(atomic_read(&j->DSPWrite) > 0)
6771 atomic_dec(&j->DSPWrite);
6772 if (ixjdebug & 0x0002)
6773 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6774 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6775
6776 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6777 return -1;
6778 /* The read values of the SSR should be 0x00 for the IDLE command */
6779 if (j->ssr.low || j->ssr.high)
6780 return -1;
6781 if (ixjdebug & 0x0002)
6782 printk(KERN_INFO "Get Device ID Code\n");
6783 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6784 return -1;
6785 j->dsp.low = j->ssr.low;
6786 j->dsp.high = j->ssr.high;
6787 if (ixjdebug & 0x0002)
6788 printk(KERN_INFO "Get Device Version Code\n");
6789 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6790 return -1;
6791 j->ver.low = j->ssr.low;
6792 j->ver.high = j->ssr.high;
6793 if (!j->cardtype) {
6794 if (j->dsp.low == 0x21) {
6795 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6796 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6797 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6798 bytes.low = inb_p(j->XILINXbase + 0x02);
6799 if (bytes.low == bytes.high) /* Register is read only on */
6800 /* Internet PhoneJack Lite */
6801 {
6802 j->cardtype = QTI_PHONEJACK_LITE;
6803 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6804 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6805 return -1;
6806 }
6807 j->pld_slicw.pcib.e1 = 1;
6808 outb_p(j->pld_slicw.byte, j->XILINXbase);
6809 } else {
6810 j->cardtype = QTI_LINEJACK;
6811
6812 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6813 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6814 return -1;
6815 }
6816 }
6817 } else if (j->dsp.low == 0x22) {
6818 j->cardtype = QTI_PHONEJACK_PCI;
6819 request_region(j->XILINXbase, 4, "ixj control");
6820 j->pld_slicw.pcib.e1 = 1;
6821 outb_p(j->pld_slicw.byte, j->XILINXbase);
6822 } else
6823 j->cardtype = QTI_PHONEJACK;
6824 } else {
6825 switch (j->cardtype) {
6826 case QTI_PHONEJACK:
6827 if (!j->dsp.low != 0x20) {
6828 j->dsp.high = 0x80;
6829 j->dsp.low = 0x20;
6830 ixj_WriteDSPCommand(0x3800, j);
6831 j->ver.low = j->ssr.low;
6832 j->ver.high = j->ssr.high;
6833 }
6834 break;
6835 case QTI_LINEJACK:
6836 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6837 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6838 return -1;
6839 }
6840 break;
6841 case QTI_PHONEJACK_LITE:
6842 case QTI_PHONEJACK_PCI:
6843 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6844 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6845 return -1;
6846 }
6847 j->pld_slicw.pcib.e1 = 1;
6848 outb_p(j->pld_slicw.byte, j->XILINXbase);
6849 break;
6850 case QTI_PHONECARD:
6851 break;
6852 }
6853 }
6854 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6855 if (ixjdebug & 0x0002)
6856 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6857 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6858 return -1;
6859 if (ixjdebug & 0x0002)
6860 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6861 if (j->cardtype == QTI_PHONEJACK) {
6862 cmd = 0x9FF2;
6863 } else {
6864 cmd = 0x9FF5;
6865 }
6866 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6867 return -1;
6868 } else {
6869 if (set_base_frame(j, 30) != 30)
6870 return -1;
6871 if (ixjdebug & 0x0002)
6872 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6873 if (j->cardtype == QTI_PHONECARD) {
6874 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6875 return -1;
6876 }
6877 if (j->cardtype == QTI_LINEJACK) {
6878 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6879 return -1;
6880 if (ixjdebug & 0x0002)
6881 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6882 j->pld_clock.byte = 0;
6883 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6884 }
6885 }
6886
6887 if (j->dsp.low == 0x20) {
6888 if (ixjdebug & 0x0002)
6889 printk(KERN_INFO "Configure GPIO pins\n");
6890 j->gpio.bytes.high = 0x09;
6891 /* bytes.low = 0xEF; 0xF7 */
6892 j->gpio.bits.gpio1 = 1;
6893 j->gpio.bits.gpio2 = 1;
6894 j->gpio.bits.gpio3 = 0;
6895 j->gpio.bits.gpio4 = 1;
6896 j->gpio.bits.gpio5 = 1;
6897 j->gpio.bits.gpio6 = 1;
6898 j->gpio.bits.gpio7 = 1;
6899 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6900 if (ixjdebug & 0x0002)
6901 printk(KERN_INFO "Enable SLIC\n");
6902 j->gpio.bytes.high = 0x0B;
6903 j->gpio.bytes.low = 0x00;
6904 j->gpio.bits.gpio1 = 0;
6905 j->gpio.bits.gpio2 = 1;
6906 j->gpio.bits.gpio5 = 0;
6907 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6908 j->port = PORT_POTS;
6909 } else {
6910 if (j->cardtype == QTI_LINEJACK) {
6911 LED_SetState(0x1, j);
6912 msleep(100);
6913 LED_SetState(0x2, j);
6914 msleep(100);
6915 LED_SetState(0x4, j);
6916 msleep(100);
6917 LED_SetState(0x8, j);
6918 msleep(100);
6919 LED_SetState(0x0, j);
6920 daa_get_version(j);
6921 if (ixjdebug & 0x0002)
6922 printk("Loading DAA Coefficients\n");
6923 DAA_Coeff_US(j);
6924 if (!ixj_daa_write(j)) {
6925 printk("DAA write failed on board %d\n", j->board);
6926 return -1;
6927 }
6928 if(!ixj_daa_cid_reset(j)) {
6929 printk("DAA CID reset failed on board %d\n", j->board);
6930 return -1;
6931 }
6932 j->flags.pots_correct = 0;
6933 j->flags.pstn_present = 0;
6934 ixj_linetest(j);
6935 if (j->flags.pots_correct) {
6936 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6937
6938 outb_p(j->pld_scrw.byte, j->XILINXbase);
6939 j->pld_slicw.bits.rly1 = 1;
6940 j->pld_slicw.bits.spken = 1;
6941 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6942 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6943 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6944 j->port = PORT_POTS;
6945 }
6946 ixj_set_port(j, PORT_PSTN);
6947 ixj_set_pots(j, 1);
6948 if (ixjdebug & 0x0002)
6949 printk(KERN_INFO "Enable Mixer\n");
6950 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6951 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6952
6953 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6954 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6955
6956 ixj_mixer(0x0480, j); /*FM Left mute */
6957 ixj_mixer(0x0580, j); /*FM Right mute */
6958
6959 ixj_mixer(0x0680, j); /*CD Left mute */
6960 ixj_mixer(0x0780, j); /*CD Right mute */
6961
6962 ixj_mixer(0x0880, j); /*Line Left mute */
6963 ixj_mixer(0x0980, j); /*Line Right mute */
6964
6965 ixj_mixer(0x0A80, j); /*Aux left mute */
6966 ixj_mixer(0x0B80, j); /*Aux right mute */
6967
6968 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6969 ixj_mixer(0x0D80, j); /*Mono2 mute */
6970
6971 ixj_mixer(0x0E80, j); /*Mic mute */
6972
6973 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6974
6975 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6976 ixj_mixer(0x110C, j);
6977
6978
6979 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6980 ixj_mixer(0x1401, j);
6981
6982 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6983 ixj_mixer(0x1501, j);
6984
6985 ixj_mixer(0x1700, j); /*Clock select */
6986
6987 ixj_mixer(0x1800, j); /*ADC input from mixer */
6988
6989 ixj_mixer(0x1901, j); /*Mic gain 30db */
6990
6991 if (ixjdebug & 0x0002)
6992 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6993 j->cadence_f[4].state = 0;
6994 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6995 j->cadence_f[4].off1 = 0;
6996 j->cadence_f[4].on2 = 0;
6997 j->cadence_f[4].off2 = 0;
6998 j->cadence_f[4].on3 = 0;
6999 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7000 j->pstn_last_rmr = jiffies;
7001
7002 } else {
7003 if (j->cardtype == QTI_PHONECARD) {
7004 ixj_WriteDSPCommand(0xCF07, j);
7005 ixj_WriteDSPCommand(0x00B0, j);
7006 ixj_set_port(j, PORT_SPEAKER);
7007 } else {
7008 ixj_set_port(j, PORT_POTS);
7009 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7010 /* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7011 }
7012 }
7013 }
7014
7015 j->intercom = -1;
7016 j->framesread = j->frameswritten = 0;
7017 j->read_wait = j->write_wait = 0;
7018 j->rxreadycheck = j->txreadycheck = 0;
7019
7020 /* initialise the DTMF prescale to a sensible value */
7021 if (j->cardtype == QTI_LINEJACK) {
7022 set_dtmf_prescale(j, 0x10);
7023 } else {
7024 set_dtmf_prescale(j, 0x40);
7025 }
7026 set_play_volume(j, 0x100);
7027 set_rec_volume(j, 0x100);
7028
7029 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7030 return -1;
7031 /* The read values of the SSR should be 0x00 for the IDLE command */
7032 if (j->ssr.low || j->ssr.high)
7033 return -1;
7034
7035 if (ixjdebug & 0x0002)
7036 printk(KERN_INFO "Enable Line Monitor\n");
7037
7038 if (ixjdebug & 0x0002)
7039 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7040
7041 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7042 return -1;
7043
7044 if (ixjdebug & 0x002)
7045 printk(KERN_INFO "Enable DTMF Detectors\n");
7046
7047 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7048 return -1;
7049
7050 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7051 return -1;
7052
7053 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7054
7055 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7056
7057 j->ex.bits.dtmf_ready = 0;
7058 j->dtmf_state = 0;
7059 j->dtmf_wp = j->dtmf_rp = 0;
7060 j->rec_mode = j->play_mode = -1;
7061 j->flags.ringing = 0;
7062 j->maxrings = MAXRINGS;
7063 j->ring_cadence = USA_RING_CADENCE;
7064 j->drybuffer = 0;
7065 j->winktime = 320;
7066 j->flags.dtmf_oob = 0;
7067 for (cnt = 0; cnt < 4; cnt++)
7068 j->cadence_f[cnt].enable = 0;
7069 /* must be a device on the specified address */
7070 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7071
7072 /* Set up the default signals for events */
7073 for (cnt = 0; cnt < 35; cnt++)
7074 j->ixj_signals[cnt] = SIGIO;
7075
7076 /* Set the excetion signal enable flags */
7077 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7078 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 =
7079 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;
7080 #ifdef IXJ_DYN_ALLOC
7081 j->fskdata = NULL;
7082 #endif
7083 j->fskdcnt = 0;
7084 j->cidcw_wait = 0;
7085
7086 /* Register with the Telephony for Linux subsystem */
7087 j->p.f_op = &ixj_fops;
7088 j->p.open = ixj_open;
7089 j->p.board = j->board;
7090 phone_register_device(&j->p, PHONE_UNIT_ANY);
7091
7092 ixj_init_timer(j);
7093 ixj_add_timer(j);
7094 return 0;
7095 }
7096
7097 /*
7098 * Exported service for pcmcia card handling
7099 */
7100
7101 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7102 {
7103 IXJ *j = ixj_alloc();
7104
7105 j->board = 0;
7106
7107 j->DSPbase = dsp;
7108 j->XILINXbase = xilinx;
7109 j->cardtype = QTI_PHONECARD;
7110 ixj_selfprobe(j);
7111 return j;
7112 }
7113
7114 EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7115
7116 static int ixj_get_status_proc(char *buf)
7117 {
7118 int len;
7119 int cnt;
7120 IXJ *j;
7121 len = 0;
7122 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7123 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7124 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7125 len += sprintf(buf + len, "\nUsing old telephony API");
7126 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7127
7128 for (cnt = 0; cnt < IXJMAX; cnt++) {
7129 j = get_ixj(cnt);
7130 if(j==NULL)
7131 continue;
7132 if (j->DSPbase) {
7133 len += sprintf(buf + len, "\nCard Num %d", cnt);
7134 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7135 if (j->cardtype != QTI_PHONEJACK)
7136 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7137 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7138 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7139 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7140 switch (j->cardtype) {
7141 case (QTI_PHONEJACK):
7142 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7143 break;
7144 case (QTI_LINEJACK):
7145 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7146 if (j->flags.g729_loaded)
7147 len += sprintf(buf + len, " w/G.729 A/B");
7148 len += sprintf(buf + len, " Country = %d", j->daa_country);
7149 break;
7150 case (QTI_PHONEJACK_LITE):
7151 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7152 if (j->flags.g729_loaded)
7153 len += sprintf(buf + len, " w/G.729 A/B");
7154 break;
7155 case (QTI_PHONEJACK_PCI):
7156 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7157 if (j->flags.g729_loaded)
7158 len += sprintf(buf + len, " w/G.729 A/B");
7159 break;
7160 case (QTI_PHONECARD):
7161 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7162 if (j->flags.g729_loaded)
7163 len += sprintf(buf + len, " w/G.729 A/B");
7164 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7165 if (!j->pccr1.bits.drf)
7166 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7167 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7168 break;
7169 default:
7170 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7171 break;
7172 }
7173 len += sprintf(buf + len, "\nReaders %d", j->readers);
7174 len += sprintf(buf + len, "\nWriters %d", j->writers);
7175 add_caps(j);
7176 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7177 if (j->dsp.low != 0x20)
7178 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7179 if (j->flags.cidsent)
7180 len += sprintf(buf + len, "\nCaller ID data sent");
7181 else
7182 len += sprintf(buf + len, "\nCaller ID data not sent");
7183
7184 len += sprintf(buf + len, "\nPlay CODEC ");
7185 switch (j->play_codec) {
7186 case G723_63:
7187 len += sprintf(buf + len, "G.723.1 6.3");
7188 break;
7189 case G723_53:
7190 len += sprintf(buf + len, "G.723.1 5.3");
7191 break;
7192 case TS85:
7193 len += sprintf(buf + len, "TrueSpeech 8.5");
7194 break;
7195 case TS48:
7196 len += sprintf(buf + len, "TrueSpeech 4.8");
7197 break;
7198 case TS41:
7199 len += sprintf(buf + len, "TrueSpeech 4.1");
7200 break;
7201 case G728:
7202 len += sprintf(buf + len, "G.728");
7203 break;
7204 case G729:
7205 len += sprintf(buf + len, "G.729");
7206 break;
7207 case G729B:
7208 len += sprintf(buf + len, "G.729B");
7209 break;
7210 case ULAW:
7211 len += sprintf(buf + len, "uLaw");
7212 break;
7213 case ALAW:
7214 len += sprintf(buf + len, "aLaw");
7215 break;
7216 case LINEAR16:
7217 len += sprintf(buf + len, "16 bit Linear");
7218 break;
7219 case LINEAR8:
7220 len += sprintf(buf + len, "8 bit Linear");
7221 break;
7222 case WSS:
7223 len += sprintf(buf + len, "Windows Sound System");
7224 break;
7225 default:
7226 len += sprintf(buf + len, "NO CODEC CHOSEN");
7227 break;
7228 }
7229 len += sprintf(buf + len, "\nRecord CODEC ");
7230 switch (j->rec_codec) {
7231 case G723_63:
7232 len += sprintf(buf + len, "G.723.1 6.3");
7233 break;
7234 case G723_53:
7235 len += sprintf(buf + len, "G.723.1 5.3");
7236 break;
7237 case TS85:
7238 len += sprintf(buf + len, "TrueSpeech 8.5");
7239 break;
7240 case TS48:
7241 len += sprintf(buf + len, "TrueSpeech 4.8");
7242 break;
7243 case TS41:
7244 len += sprintf(buf + len, "TrueSpeech 4.1");
7245 break;
7246 case G728:
7247 len += sprintf(buf + len, "G.728");
7248 break;
7249 case G729:
7250 len += sprintf(buf + len, "G.729");
7251 break;
7252 case G729B:
7253 len += sprintf(buf + len, "G.729B");
7254 break;
7255 case ULAW:
7256 len += sprintf(buf + len, "uLaw");
7257 break;
7258 case ALAW:
7259 len += sprintf(buf + len, "aLaw");
7260 break;
7261 case LINEAR16:
7262 len += sprintf(buf + len, "16 bit Linear");
7263 break;
7264 case LINEAR8:
7265 len += sprintf(buf + len, "8 bit Linear");
7266 break;
7267 case WSS:
7268 len += sprintf(buf + len, "Windows Sound System");
7269 break;
7270 default:
7271 len += sprintf(buf + len, "NO CODEC CHOSEN");
7272 break;
7273 }
7274 len += sprintf(buf + len, "\nAEC ");
7275 switch (j->aec_level) {
7276 case AEC_OFF:
7277 len += sprintf(buf + len, "Off");
7278 break;
7279 case AEC_LOW:
7280 len += sprintf(buf + len, "Low");
7281 break;
7282 case AEC_MED:
7283 len += sprintf(buf + len, "Med");
7284 break;
7285 case AEC_HIGH:
7286 len += sprintf(buf + len, "High");
7287 break;
7288 case AEC_AUTO:
7289 len += sprintf(buf + len, "Auto");
7290 break;
7291 case AEC_AGC:
7292 len += sprintf(buf + len, "AEC/AGC");
7293 break;
7294 default:
7295 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7296 break;
7297 }
7298
7299 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7300 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7301 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7302
7303 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7304
7305 if (j->cardtype == QTI_LINEJACK) {
7306 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7307 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7308 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7309 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7310 switch (j->daa_mode) {
7311 case SOP_PU_SLEEP:
7312 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7313 break;
7314 case SOP_PU_RINGING:
7315 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7316 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7317 break;
7318 case SOP_PU_CONVERSATION:
7319 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7320 break;
7321 case SOP_PU_PULSEDIALING:
7322 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7323 break;
7324 }
7325 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7326 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7327 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7328 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7329 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7330 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7331 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7332 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7333 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7334 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7335 }
7336 switch (j->port) {
7337 case PORT_POTS:
7338 len += sprintf(buf + len, "\nPort POTS");
7339 break;
7340 case PORT_PSTN:
7341 len += sprintf(buf + len, "\nPort PSTN");
7342 break;
7343 case PORT_SPEAKER:
7344 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7345 break;
7346 case PORT_HANDSET:
7347 len += sprintf(buf + len, "\nPort HANDSET");
7348 break;
7349 }
7350 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7351 len += sprintf(buf + len, "\nSLIC state ");
7352 switch (SLIC_GetState(j)) {
7353 case PLD_SLIC_STATE_OC:
7354 len += sprintf(buf + len, "OC");
7355 break;
7356 case PLD_SLIC_STATE_RINGING:
7357 len += sprintf(buf + len, "RINGING");
7358 break;
7359 case PLD_SLIC_STATE_ACTIVE:
7360 len += sprintf(buf + len, "ACTIVE");
7361 break;
7362 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7363 len += sprintf(buf + len, "OHT");
7364 break;
7365 case PLD_SLIC_STATE_TIPOPEN:
7366 len += sprintf(buf + len, "TIPOPEN");
7367 break;
7368 case PLD_SLIC_STATE_STANDBY:
7369 len += sprintf(buf + len, "STANDBY");
7370 break;
7371 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7372 len += sprintf(buf + len, "APR");
7373 break;
7374 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7375 len += sprintf(buf + len, "OHTPR");
7376 break;
7377 default:
7378 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7379 break;
7380 }
7381 }
7382 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7383 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7384 #ifdef PERFMON_STATS
7385 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7386 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7387 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7388 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7389 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7390 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7391 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7392 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7393 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7394 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7395 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7396 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7397 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7398 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7399
7400 #endif
7401 len += sprintf(buf + len, "\n");
7402 }
7403 }
7404 return len;
7405 }
7406
7407 static int ixj_read_proc(char *page, char **start, off_t off,
7408 int count, int *eof, void *data)
7409 {
7410 int len = ixj_get_status_proc(page);
7411 if (len <= off+count) *eof = 1;
7412 *start = page + off;
7413 len -= off;
7414 if (len>count) len = count;
7415 if (len<0) len = 0;
7416 return len;
7417 }
7418
7419
7420 static void cleanup(void)
7421 {
7422 int cnt;
7423 IXJ *j;
7424
7425 for (cnt = 0; cnt < IXJMAX; cnt++) {
7426 j = get_ixj(cnt);
7427 if(j != NULL && j->DSPbase) {
7428 if (ixjdebug & 0x0002)
7429 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7430 del_timer(&j->timer);
7431 if (j->cardtype == QTI_LINEJACK) {
7432 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7433
7434 outb_p(j->pld_scrw.byte, j->XILINXbase);
7435 j->pld_slicw.bits.rly1 = 0;
7436 j->pld_slicw.bits.rly2 = 0;
7437 j->pld_slicw.bits.rly3 = 0;
7438 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7439 LED_SetState(0x0, j);
7440 if (ixjdebug & 0x0002)
7441 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7442 release_region(j->XILINXbase, 8);
7443 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7444 if (ixjdebug & 0x0002)
7445 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7446 release_region(j->XILINXbase, 4);
7447 }
7448 kfree(j->read_buffer);
7449 kfree(j->write_buffer);
7450 if (j->dev)
7451 pnp_device_detach(j->dev);
7452 if (ixjdebug & 0x0002)
7453 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7454 phone_unregister_device(&j->p);
7455 if (ixjdebug & 0x0002)
7456 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7457 release_region(j->DSPbase, 16);
7458 #ifdef IXJ_DYN_ALLOC
7459 if (ixjdebug & 0x0002)
7460 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7461 kfree(j);
7462 ixj[cnt] = NULL;
7463 #endif
7464 }
7465 }
7466 if (ixjdebug & 0x0002)
7467 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7468 remove_proc_entry ("ixj", NULL);
7469 }
7470
7471 /* Typedefs */
7472 typedef struct {
7473 BYTE length;
7474 DWORD bits;
7475 } DATABLOCK;
7476
7477 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7478 {
7479 lastLCC = lastLCC & 0xfb;
7480 lastLCC = lastLCC | (byData ? 4 : 0);
7481 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7482
7483 mdelay(1);
7484 lastLCC = lastLCC | 0x01;
7485 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7486
7487 byData = byData << 1;
7488 lastLCC = lastLCC & 0xfe;
7489 mdelay(1);
7490 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7491
7492 }
7493
7494 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7495 {
7496 mdelay(1);
7497 lastLCC = lastLCC | 0x01;
7498 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7499
7500 lastLCC = lastLCC & 0xfe;
7501 mdelay(1);
7502 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7503
7504 return ((inb(wEEPROMAddress) >> 3) & 1);
7505 }
7506
7507 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7508 {
7509 BYTE lastLCC;
7510 WORD wEEPROMAddress = wAddress + 3;
7511 DWORD i;
7512 BYTE byResult;
7513 *pwResult = 0;
7514 lastLCC = inb(wEEPROMAddress);
7515 lastLCC = lastLCC | 0x02;
7516 lastLCC = lastLCC & 0xfe;
7517 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7518
7519 mdelay(1); /* delay */
7520
7521 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7522 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7523 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7524 for (i = 0; i < 8; i++) {
7525 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7526 wLoc <<= 1;
7527 }
7528
7529 for (i = 0; i < 16; i++) {
7530 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7531 *pwResult = (*pwResult << 1) | byResult;
7532 }
7533
7534 mdelay(1); /* another delay */
7535
7536 lastLCC = lastLCC & 0xfd;
7537 outb(lastLCC, wEEPROMAddress); /* negate CS */
7538
7539 return 0;
7540 }
7541
7542 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7543 {
7544 WORD wLo, wHi;
7545 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7546 return 0;
7547 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7548 return 0;
7549 return (((DWORD) wHi << 16) | wLo);
7550 }
7551
7552 static int dspio[IXJMAX + 1] =
7553 {
7554 0,
7555 };
7556 static int xio[IXJMAX + 1] =
7557 {
7558 0,
7559 };
7560
7561 module_param_array(dspio, int, NULL, 0);
7562 module_param_array(xio, int, NULL, 0);
7563 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7564 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7565 MODULE_LICENSE("GPL");
7566
7567 static void __exit ixj_exit(void)
7568 {
7569 cleanup();
7570 }
7571
7572 static IXJ *new_ixj(unsigned long port)
7573 {
7574 IXJ *res;
7575 if (!request_region(port, 16, "ixj DSP")) {
7576 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7577 return NULL;
7578 }
7579 res = ixj_alloc();
7580 if (!res) {
7581 release_region(port, 16);
7582 printk(KERN_INFO "ixj: out of memory\n");
7583 return NULL;
7584 }
7585 res->DSPbase = port;
7586 return res;
7587 }
7588
7589 static int __init ixj_probe_isapnp(int *cnt)
7590 {
7591 int probe = 0;
7592 int func = 0x110;
7593 struct pnp_dev *dev = NULL, *old_dev = NULL;
7594
7595 while (1) {
7596 do {
7597 IXJ *j;
7598 int result;
7599
7600 old_dev = dev;
7601 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7602 ISAPNP_FUNCTION(func), old_dev);
7603 if (!dev || !dev->card)
7604 break;
7605 result = pnp_device_attach(dev);
7606 if (result < 0) {
7607 printk("pnp attach failed %d \n", result);
7608 break;
7609 }
7610 if (pnp_activate_dev(dev) < 0) {
7611 printk("pnp activate failed (out of resources?)\n");
7612 pnp_device_detach(dev);
7613 return -ENOMEM;
7614 }
7615
7616 if (!pnp_port_valid(dev, 0)) {
7617 pnp_device_detach(dev);
7618 return -ENODEV;
7619 }
7620
7621 j = new_ixj(pnp_port_start(dev, 0));
7622 if (!j)
7623 break;
7624
7625 if (func != 0x110)
7626 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7627
7628 switch (func) {
7629 case (0x110):
7630 j->cardtype = QTI_PHONEJACK;
7631 break;
7632 case (0x310):
7633 j->cardtype = QTI_LINEJACK;
7634 break;
7635 case (0x410):
7636 j->cardtype = QTI_PHONEJACK_LITE;
7637 break;
7638 }
7639 j->board = *cnt;
7640 probe = ixj_selfprobe(j);
7641 if(!probe) {
7642 j->serial = dev->card->serial;
7643 j->dev = dev;
7644 switch (func) {
7645 case 0x110:
7646 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7647 break;
7648 case 0x310:
7649 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7650 break;
7651 case 0x410:
7652 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7653 break;
7654 }
7655 }
7656 ++*cnt;
7657 } while (dev);
7658 if (func == 0x410)
7659 break;
7660 if (func == 0x310)
7661 func = 0x410;
7662 if (func == 0x110)
7663 func = 0x310;
7664 dev = NULL;
7665 }
7666 return probe;
7667 }
7668
7669 static int __init ixj_probe_isa(int *cnt)
7670 {
7671 int i, probe;
7672
7673 /* Use passed parameters for older kernels without PnP */
7674 for (i = 0; i < IXJMAX; i++) {
7675 if (dspio[i]) {
7676 IXJ *j = new_ixj(dspio[i]);
7677
7678 if (!j)
7679 break;
7680
7681 j->XILINXbase = xio[i];
7682 j->cardtype = 0;
7683
7684 j->board = *cnt;
7685 probe = ixj_selfprobe(j);
7686 j->dev = NULL;
7687 ++*cnt;
7688 }
7689 }
7690 return 0;
7691 }
7692
7693 static int __init ixj_probe_pci(int *cnt)
7694 {
7695 struct pci_dev *pci = NULL;
7696 int i, probe = 0;
7697 IXJ *j = NULL;
7698
7699 for (i = 0; i < IXJMAX - *cnt; i++) {
7700 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7701 PCI_DEVICE_ID_QUICKNET_XJ, pci);
7702 if (!pci)
7703 break;
7704
7705 if (pci_enable_device(pci))
7706 break;
7707 j = new_ixj(pci_resource_start(pci, 0));
7708 if (!j)
7709 break;
7710
7711 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7712 j->XILINXbase = j->DSPbase + 0x10;
7713 j->cardtype = QTI_PHONEJACK_PCI;
7714 j->board = *cnt;
7715 probe = ixj_selfprobe(j);
7716 if (!probe)
7717 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7718 ++*cnt;
7719 }
7720 pci_dev_put(pci);
7721 return probe;
7722 }
7723
7724 static int __init ixj_init(void)
7725 {
7726 int cnt = 0;
7727 int probe = 0;
7728
7729 cnt = 0;
7730
7731 /* These might be no-ops, see above. */
7732 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7733 return probe;
7734 }
7735 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7736 return probe;
7737 }
7738 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7739 return probe;
7740 }
7741 printk(KERN_INFO "ixj driver initialized.\n");
7742 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7743 return probe;
7744 }
7745
7746 module_init(ixj_init);
7747 module_exit(ixj_exit);
7748
7749 static void DAA_Coeff_US(IXJ *j)
7750 {
7751 int i;
7752
7753 j->daa_country = DAA_US;
7754 /*----------------------------------------------- */
7755 /* CAO */
7756 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7757 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7758 }
7759
7760 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7761 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7762 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7769 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7778 /* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7779 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7780 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7787 /* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7796 /* Bytes for AX-filter (0A): 16,55,DD,CA */
7797 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7798 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7799 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7800 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7801 /* Bytes for AR-filter (09): 52,D3,11,42 */
7802 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7803 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7804 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7805 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7806 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7807 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7815 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7824 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7833 /* ; (10K, 0.68uF) */
7834 /* */
7835 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7836 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7837 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7844 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7853
7854 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7855 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7856 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7857 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7858 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7859
7860 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7861 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7862 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7863 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7864 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7865 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7866 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7867 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7868 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7869 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7870 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7871 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7872 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7873 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7874 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7875 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7876 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7877 /* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7878 /* */
7879 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7880 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7881 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7882 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7883 /* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7884
7885 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7886 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7887 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7894 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7903 /* */
7904 /* ;CR Registers */
7905 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7906 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7907 /* Config. Reg. 1 (dialing) (cr1):05 */
7908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7909 /* Config. Reg. 2 (caller ID) (cr2):04 */
7910 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7911 /* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7912 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7913 /* Config. Reg. 4 (analog gain) (cr4):02 */
7914 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7915 /* Config. Reg. 5 (Version) (cr5):02 */
7916 /* Config. Reg. 6 (Reserved) (cr6):00 */
7917 /* Config. Reg. 7 (Reserved) (cr7):00 */
7918 /* */
7919 /* ;xr Registers */
7920 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7921
7922 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7923 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7924
7925 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7926 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7927 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7928 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7929 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7930 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7931
7932 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7933 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
7934 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7935 /* Ext. Reg. 6 (Power State) (xr6):00 */
7936 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7937 /* Ext. Reg. 7 (Vdd) (xr7):40 */
7938 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7939 /* */
7940 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7941 /* 12,33,5A,C3 ; 770 Hz */
7942 /* 13,3C,5B,32 ; 852 Hz */
7943 /* 1D,1B,5C,CC ; 941 Hz */
7944
7945 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7946 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7947 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7949 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7950 /* EC,1D,52,22 ; 1336 Hz */
7951 /* AA,AC,51,D2 ; 1477 Hz */
7952 /* 9B,3B,51,25 ; 1633 Hz */
7953 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7954 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7957 }
7958
7959 static void DAA_Coeff_UK(IXJ *j)
7960 {
7961 int i;
7962
7963 j->daa_country = DAA_UK;
7964 /*----------------------------------------------- */
7965 /* CAO */
7966 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7967 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7968 }
7969
7970 /* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7971 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7972 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7979 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7988 /* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7989 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7990 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7997 /* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8006 /* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8007 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8008 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8009 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8010 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8011 /* Bytes for AR-filter (09): E2,27,10,D6 */
8012 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8013 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8014 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8015 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8016 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8017 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8018 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8025 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8034 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8043 /* ; idle */
8044 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8045 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8046 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8053 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8062 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8063 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8064 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8065 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8066 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8067 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8068 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8069 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8076 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8085 /* ;CR Registers */
8086 /* Config. Reg. 0 (filters) (cr0):FF */
8087 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8088 /* Config. Reg. 1 (dialing) (cr1):05 */
8089 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8090 /* Config. Reg. 2 (caller ID) (cr2):04 */
8091 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8092 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8093 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8094 /* Config. Reg. 4 (analog gain) (cr4):02 */
8095 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8096 /* Config. Reg. 5 (Version) (cr5):02 */
8097 /* Config. Reg. 6 (Reserved) (cr6):00 */
8098 /* Config. Reg. 7 (Reserved) (cr7):00 */
8099 /* ;xr Registers */
8100 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8101
8102 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8103 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8104
8105 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8106 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8107
8108 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8109 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8110 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8111 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8112 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8113 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8114 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8115 /* Ext. Reg. 6 (Power State) (xr6):00 */
8116 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8117 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8118 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8119 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8120 /* 12,33,5A,C3 ; 770 Hz */
8121 /* 13,3C,5B,32 ; 852 Hz */
8122 /* 1D,1B,5C,CC ; 941 Hz */
8123
8124 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8125 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8126 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8128 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8129 /* EC,1D,52,22 ; 1336 Hz */
8130 /* AA,AC,51,D2 ; 1477 Hz */
8131 /* 9B,3B,51,25 ; 1633 Hz */
8132 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8133 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8136 }
8137
8138
8139 static void DAA_Coeff_France(IXJ *j)
8140 {
8141 int i;
8142
8143 j->daa_country = DAA_FRANCE;
8144 /*----------------------------------------------- */
8145 /* CAO */
8146 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8147 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8148 }
8149
8150 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8151 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8152 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8159 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8168 /* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8169 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8170 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8177 /* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8186 /* Bytes for AX-filter (0A): 16,B5,DD,CA */
8187 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8188 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8189 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8190 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8191 /* Bytes for AR-filter (09): 52,C7,10,D6 */
8192 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8193 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8194 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8195 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8196 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8197 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8198 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8205 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8214 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8223 /* ; idle */
8224 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8225 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8226 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8233 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8242 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8243 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8244 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8245 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8246 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8247 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8248 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8249 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8256 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8265 /* ;CR Registers */
8266 /* Config. Reg. 0 (filters) (cr0):FF */
8267 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8268 /* Config. Reg. 1 (dialing) (cr1):05 */
8269 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8270 /* Config. Reg. 2 (caller ID) (cr2):04 */
8271 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8272 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8273 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8274 /* Config. Reg. 4 (analog gain) (cr4):02 */
8275 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8276 /* Config. Reg. 5 (Version) (cr5):02 */
8277 /* Config. Reg. 6 (Reserved) (cr6):00 */
8278 /* Config. Reg. 7 (Reserved) (cr7):00 */
8279 /* ;xr Registers */
8280 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8281
8282 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8283 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8284
8285 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8286 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8287
8288 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8289 /* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8290 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8291 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8292 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8293 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8294 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8295 /* Ext. Reg. 6 (Power State) (xr6):00 */
8296 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8297 /* Ext. Reg. 7 (Vdd) (xr7):46 */
8298 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8299 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8300 /* 12,33,5A,C3 ; 770 Hz */
8301 /* 13,3C,5B,32 ; 852 Hz */
8302 /* 1D,1B,5C,CC ; 941 Hz */
8303
8304 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8305 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8306 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8308 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8309 /* EC,1D,52,22 ; 1336 Hz */
8310 /* AA,AC,51,D2 ; 1477 Hz */
8311 /* 9B,3B,51,25 ; 1633 Hz */
8312 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8313 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8316 }
8317
8318
8319 static void DAA_Coeff_Germany(IXJ *j)
8320 {
8321 int i;
8322
8323 j->daa_country = DAA_GERMANY;
8324 /*----------------------------------------------- */
8325 /* CAO */
8326 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8327 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8328 }
8329
8330 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8331 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8332 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8339 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8348 /* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8349 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8350 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8357 /* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8366 /* Bytes for AX-filter (0A): 72,D5,DD,CA */
8367 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8368 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8369 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8370 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8371 /* Bytes for AR-filter (09): 72,42,13,4B */
8372 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8373 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8374 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8375 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8376 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8377 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8378 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8385 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8394 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8403 /* ; (10K, 0.68uF) */
8404 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8405 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8406 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8413 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8422 /* Levelmetering Ringing (0D):B2,45,0F,8E */
8423 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8424 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8425 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8426 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8427 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8428 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8429 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8436 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8445 /* ;CR Registers */
8446 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8447 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8448 /* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8449 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8450 /* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8451 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8452 /* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8453 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8454 /* Config. Reg. 4 (analog gain) (cr4):02 */
8455 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8456 /* Config. Reg. 5 (Version) (cr5):02 */
8457 /* Config. Reg. 6 (Reserved) (cr6):00 */
8458 /* Config. Reg. 7 (Reserved) (cr7):00 */
8459 /* ;xr Registers */
8460 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8461
8462 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8463 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8464
8465 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8466 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8467
8468 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8469 /* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8470 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8471 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8472 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8473 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8474 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8475 /* Ext. Reg. 6 (Power State) (xr6):00 */
8476 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8477 /* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8478 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8479 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8480 /* 12,33,5A,C3 ; 770 Hz */
8481 /* 13,3C,5B,32 ; 852 Hz */
8482 /* 1D,1B,5C,CC ; 941 Hz */
8483
8484 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8485 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8486 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8488 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8489 /* EC,1D,52,22 ; 1336 Hz */
8490 /* AA,AC,51,D2 ; 1477 Hz */
8491 /* 9B,3B,51,25 ; 1633 Hz */
8492 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8493 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8496 }
8497
8498
8499 static void DAA_Coeff_Australia(IXJ *j)
8500 {
8501 int i;
8502
8503 j->daa_country = DAA_AUSTRALIA;
8504 /*----------------------------------------------- */
8505 /* CAO */
8506 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8507 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8508 }
8509
8510 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8511 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8512 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8519 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8528 /* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8529 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8530 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8537 /* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8546 /* Bytes for AX-filter (0A): CB,45,DD,CA */
8547 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8548 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8549 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8550 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8551 /* Bytes for AR-filter (09): 1B,67,10,D6 */
8552 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8553 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8554 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8555 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8556 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8557 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8558 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8565 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8574 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8583 /* ; idle */
8584 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8585 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8586 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8593 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8602 /* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8603 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8604 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8605 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8606 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8607 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8608 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8609 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8616 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8625 /* ;CR Registers */
8626 /* Config. Reg. 0 (filters) (cr0):FF */
8627 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8628 /* Config. Reg. 1 (dialing) (cr1):05 */
8629 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8630 /* Config. Reg. 2 (caller ID) (cr2):04 */
8631 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8632 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8633 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8634 /* Config. Reg. 4 (analog gain) (cr4):02 */
8635 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8636 /* Config. Reg. 5 (Version) (cr5):02 */
8637 /* Config. Reg. 6 (Reserved) (cr6):00 */
8638 /* Config. Reg. 7 (Reserved) (cr7):00 */
8639 /* ;xr Registers */
8640 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8641
8642 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8643 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8644
8645 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8646 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8647
8648 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8649 /* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8650 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8651 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8652 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8653 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8654 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8655 /* Ext. Reg. 6 (Power State) (xr6):00 */
8656 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8657 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8658 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8659
8660 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8661 /* 12,33,5A,C3 ; 770 Hz */
8662 /* 13,3C,5B,32 ; 852 Hz */
8663 /* 1D,1B,5C,CC ; 941 Hz */
8664 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8665 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8666 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8668
8669 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8670 /* EC,1D,52,22 ; 1336 Hz */
8671 /* AA,AC,51,D2 ; 1477 Hz */
8672 /* 9B,3B,51,25 ; 1633 Hz */
8673 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8674 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8675 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8677 }
8678
8679 static void DAA_Coeff_Japan(IXJ *j)
8680 {
8681 int i;
8682
8683 j->daa_country = DAA_JAPAN;
8684 /*----------------------------------------------- */
8685 /* CAO */
8686 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8687 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8688 }
8689
8690 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8691 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8692 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8699 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8708 /* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8709 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8710 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8717 /* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8726 /* Bytes for AX-filter (0A): 51,C5,DD,CA */
8727 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8728 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8729 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8730 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8731 /* Bytes for AR-filter (09): 25,A7,10,D6 */
8732 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8733 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8734 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8735 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8736 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8737 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8738 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8745 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8754 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8763 /* ; idle */
8764 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8765 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8766 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8773 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8782 /* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8783 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8784 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8785 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8786 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8787 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8788 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8789 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8796 /* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8805 /* ;CR Registers */
8806 /* Config. Reg. 0 (filters) (cr0):FF */
8807 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8808 /* Config. Reg. 1 (dialing) (cr1):05 */
8809 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8810 /* Config. Reg. 2 (caller ID) (cr2):04 */
8811 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8812 /* Config. Reg. 3 (testloops) (cr3):00 ; */
8813 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8814 /* Config. Reg. 4 (analog gain) (cr4):02 */
8815 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8816 /* Config. Reg. 5 (Version) (cr5):02 */
8817 /* Config. Reg. 6 (Reserved) (cr6):00 */
8818 /* Config. Reg. 7 (Reserved) (cr7):00 */
8819 /* ;xr Registers */
8820 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8821
8822 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8823 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8824
8825 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8826 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8827
8828 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8829 /* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8830 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8831 /* Ext. Reg. 4 (Cadence) (xr4):00 */
8832 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8833 /* Ext. Reg. 5 (Ring timer) (xr5):22 */
8834 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8835 /* Ext. Reg. 6 (Power State) (xr6):00 */
8836 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8837 /* Ext. Reg. 7 (Vdd) (xr7):40 */
8838 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8839 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8840 /* 12,33,5A,C3 ; 770 Hz */
8841 /* 13,3C,5B,32 ; 852 Hz */
8842 /* 1D,1B,5C,CC ; 941 Hz */
8843
8844 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8845 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8846 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8848 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8849 /* EC,1D,52,22 ; 1336 Hz */
8850 /* AA,AC,51,D2 ; 1477 Hz */
8851 /* 9B,3B,51,25 ; 1633 Hz */
8852 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8853 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8856 }
8857
8858 static s16 tone_table[][19] =
8859 {
8860 { /* f20_50[] 11 */
8861 32538, /* A1 = 1.985962 */
8862 -32325, /* A2 = -0.986511 */
8863 -343, /* B2 = -0.010493 */
8864 0, /* B1 = 0 */
8865 343, /* B0 = 0.010493 */
8866 32619, /* A1 = 1.990906 */
8867 -32520, /* A2 = -0.992462 */
8868 19179, /* B2 = 0.585327 */
8869 -19178, /* B1 = -1.170593 */
8870 19179, /* B0 = 0.585327 */
8871 32723, /* A1 = 1.997314 */
8872 -32686, /* A2 = -0.997528 */
8873 9973, /* B2 = 0.304352 */
8874 -9955, /* B1 = -0.607605 */
8875 9973, /* B0 = 0.304352 */
8876 7, /* Internal filter scaling */
8877 159, /* Minimum in-band energy threshold */
8878 21, /* 21/32 in-band to broad-band ratio */
8879 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8880 },
8881 { /* f133_200[] 12 */
8882 32072, /* A1 = 1.95752 */
8883 -31896, /* A2 = -0.973419 */
8884 -435, /* B2 = -0.013294 */
8885 0, /* B1 = 0 */
8886 435, /* B0 = 0.013294 */
8887 32188, /* A1 = 1.9646 */
8888 -32400, /* A2 = -0.98877 */
8889 15139, /* B2 = 0.462036 */
8890 -14882, /* B1 = -0.908356 */
8891 15139, /* B0 = 0.462036 */
8892 32473, /* A1 = 1.981995 */
8893 -32524, /* A2 = -0.992584 */
8894 23200, /* B2 = 0.708008 */
8895 -23113, /* B1 = -1.410706 */
8896 23200, /* B0 = 0.708008 */
8897 7, /* Internal filter scaling */
8898 159, /* Minimum in-band energy threshold */
8899 21, /* 21/32 in-band to broad-band ratio */
8900 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8901 },
8902 { /* f300 13 */
8903 31769, /* A1 = -1.939026 */
8904 -32584, /* A2 = 0.994385 */
8905 -475, /* B2 = -0.014522 */
8906 0, /* B1 = 0.000000 */
8907 475, /* B0 = 0.014522 */
8908 31789, /* A1 = -1.940247 */
8909 -32679, /* A2 = 0.997284 */
8910 17280, /* B2 = 0.527344 */
8911 -16865, /* B1 = -1.029358 */
8912 17280, /* B0 = 0.527344 */
8913 31841, /* A1 = -1.943481 */
8914 -32681, /* A2 = 0.997345 */
8915 543, /* B2 = 0.016579 */
8916 -525, /* B1 = -0.032097 */
8917 543, /* B0 = 0.016579 */
8918 5, /* Internal filter scaling */
8919 159, /* Minimum in-band energy threshold */
8920 21, /* 21/32 in-band to broad-band ratio */
8921 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8922 },
8923 { /* f300_420[] 14 */
8924 30750, /* A1 = 1.876892 */
8925 -31212, /* A2 = -0.952515 */
8926 -804, /* B2 = -0.024541 */
8927 0, /* B1 = 0 */
8928 804, /* B0 = 0.024541 */
8929 30686, /* A1 = 1.872925 */
8930 -32145, /* A2 = -0.980988 */
8931 14747, /* B2 = 0.450043 */
8932 -13703, /* B1 = -0.836395 */
8933 14747, /* B0 = 0.450043 */
8934 31651, /* A1 = 1.931824 */
8935 -32321, /* A2 = -0.986389 */
8936 24425, /* B2 = 0.745422 */
8937 -23914, /* B1 = -1.459595 */
8938 24427, /* B0 = 0.745483 */
8939 7, /* Internal filter scaling */
8940 159, /* Minimum in-band energy threshold */
8941 21, /* 21/32 in-band to broad-band ratio */
8942 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8943 },
8944 { /* f330 15 */
8945 31613, /* A1 = -1.929565 */
8946 -32646, /* A2 = 0.996277 */
8947 -185, /* B2 = -0.005657 */
8948 0, /* B1 = 0.000000 */
8949 185, /* B0 = 0.005657 */
8950 31620, /* A1 = -1.929932 */
8951 -32713, /* A2 = 0.998352 */
8952 19253, /* B2 = 0.587585 */
8953 -18566, /* B1 = -1.133179 */
8954 19253, /* B0 = 0.587585 */
8955 31674, /* A1 = -1.933228 */
8956 -32715, /* A2 = 0.998413 */
8957 2575, /* B2 = 0.078590 */
8958 -2495, /* B1 = -0.152283 */
8959 2575, /* B0 = 0.078590 */
8960 5, /* Internal filter scaling */
8961 159, /* Minimum in-band energy threshold */
8962 21, /* 21/32 in-band to broad-band ratio */
8963 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8964 },
8965 { /* f300_425[] 16 */
8966 30741, /* A1 = 1.876282 */
8967 -31475, /* A2 = -0.960541 */
8968 -703, /* B2 = -0.021484 */
8969 0, /* B1 = 0 */
8970 703, /* B0 = 0.021484 */
8971 30688, /* A1 = 1.873047 */
8972 -32248, /* A2 = -0.984161 */
8973 14542, /* B2 = 0.443787 */
8974 -13523, /* B1 = -0.825439 */
8975 14542, /* B0 = 0.443817 */
8976 31494, /* A1 = 1.922302 */
8977 -32366, /* A2 = -0.987762 */
8978 21577, /* B2 = 0.658508 */
8979 -21013, /* B1 = -1.282532 */
8980 21577, /* B0 = 0.658508 */
8981 7, /* Internal filter scaling */
8982 159, /* Minimum in-band energy threshold */
8983 21, /* 21/32 in-band to broad-band ratio */
8984 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8985 },
8986 { /* f330_440[] 17 */
8987 30627, /* A1 = 1.869324 */
8988 -31338, /* A2 = -0.95636 */
8989 -843, /* B2 = -0.025749 */
8990 0, /* B1 = 0 */
8991 843, /* B0 = 0.025749 */
8992 30550, /* A1 = 1.864685 */
8993 -32221, /* A2 = -0.983337 */
8994 13594, /* B2 = 0.414886 */
8995 -12589, /* B1 = -0.768402 */
8996 13594, /* B0 = 0.414886 */
8997 31488, /* A1 = 1.921936 */
8998 -32358, /* A2 = -0.987518 */
8999 24684, /* B2 = 0.753296 */
9000 -24029, /* B1 = -1.466614 */
9001 24684, /* B0 = 0.753296 */
9002 7, /* Internal filter scaling */
9003 159, /* Minimum in-band energy threshold */
9004 21, /* 21/32 in-band to broad-band ratio */
9005 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9006 },
9007 { /* f340 18 */
9008 31546, /* A1 = -1.925476 */
9009 -32646, /* A2 = 0.996277 */
9010 -445, /* B2 = -0.013588 */
9011 0, /* B1 = 0.000000 */
9012 445, /* B0 = 0.013588 */
9013 31551, /* A1 = -1.925781 */
9014 -32713, /* A2 = 0.998352 */
9015 23884, /* B2 = 0.728882 */
9016 -22979, /* B1 = -1.402527 */
9017 23884, /* B0 = 0.728882 */
9018 31606, /* A1 = -1.929138 */
9019 -32715, /* A2 = 0.998413 */
9020 863, /* B2 = 0.026367 */
9021 -835, /* B1 = -0.050985 */
9022 863, /* B0 = 0.026367 */
9023 5, /* 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 { /* f350_400[] 19 */
9029 31006, /* A1 = 1.892517 */
9030 -32029, /* A2 = -0.977448 */
9031 -461, /* B2 = -0.014096 */
9032 0, /* B1 = 0 */
9033 461, /* B0 = 0.014096 */
9034 30999, /* A1 = 1.892029 */
9035 -32487, /* A2 = -0.991455 */
9036 11325, /* B2 = 0.345612 */
9037 -10682, /* B1 = -0.651978 */
9038 11325, /* B0 = 0.345612 */
9039 31441, /* A1 = 1.919067 */
9040 -32526, /* A2 = -0.992615 */
9041 24324, /* B2 = 0.74231 */
9042 -23535, /* B1 = -1.436523 */
9043 24324, /* B0 = 0.74231 */
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 { /* f350_440[] */
9050 30634, /* A1 = 1.869751 */
9051 -31533, /* A2 = -0.962341 */
9052 -680, /* B2 = -0.020782 */
9053 0, /* B1 = 0 */
9054 680, /* B0 = 0.020782 */
9055 30571, /* A1 = 1.865906 */
9056 -32277, /* A2 = -0.985016 */
9057 12894, /* B2 = 0.393524 */
9058 -11945, /* B1 = -0.729065 */
9059 12894, /* B0 = 0.393524 */
9060 31367, /* A1 = 1.91449 */
9061 -32379, /* A2 = -0.988129 */
9062 23820, /* B2 = 0.726929 */
9063 -23104, /* B1 = -1.410217 */
9064 23820, /* B0 = 0.726929 */
9065 7, /* 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 { /* f350_450[] */
9071 30552, /* A1 = 1.864807 */
9072 -31434, /* A2 = -0.95929 */
9073 -690, /* B2 = -0.021066 */
9074 0, /* B1 = 0 */
9075 690, /* B0 = 0.021066 */
9076 30472, /* A1 = 1.859924 */
9077 -32248, /* A2 = -0.984161 */
9078 13385, /* B2 = 0.408478 */
9079 -12357, /* B1 = -0.754242 */
9080 13385, /* B0 = 0.408478 */
9081 31358, /* A1 = 1.914001 */
9082 -32366, /* A2 = -0.987732 */
9083 26488, /* B2 = 0.80835 */
9084 -25692, /* B1 = -1.568176 */
9085 26490, /* B0 = 0.808411 */
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 { /* f360 */
9092 31397, /* A1 = -1.916321 */
9093 -32623, /* A2 = 0.995605 */
9094 -117, /* B2 = -0.003598 */
9095 0, /* B1 = 0.000000 */
9096 117, /* B0 = 0.003598 */
9097 31403, /* A1 = -1.916687 */
9098 -32700, /* A2 = 0.997925 */
9099 3388, /* B2 = 0.103401 */
9100 -3240, /* B1 = -0.197784 */
9101 3388, /* B0 = 0.103401 */
9102 31463, /* A1 = -1.920410 */
9103 -32702, /* A2 = 0.997986 */
9104 13346, /* B2 = 0.407288 */
9105 -12863, /* B1 = -0.785126 */
9106 13346, /* B0 = 0.407288 */
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 { /* f380_420[] */
9113 30831, /* A1 = 1.881775 */
9114 -32064, /* A2 = -0.978546 */
9115 -367, /* B2 = -0.01122 */
9116 0, /* B1 = 0 */
9117 367, /* B0 = 0.01122 */
9118 30813, /* A1 = 1.880737 */
9119 -32456, /* A2 = -0.990509 */
9120 11068, /* B2 = 0.337769 */
9121 -10338, /* B1 = -0.631042 */
9122 11068, /* B0 = 0.337769 */
9123 31214, /* A1 = 1.905212 */
9124 -32491, /* A2 = -0.991577 */
9125 16374, /* B2 = 0.499695 */
9126 -15781, /* B1 = -0.963196 */
9127 16374, /* B0 = 0.499695 */
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 { /* f392 */
9134 31152, /* A1 = -1.901428 */
9135 -32613, /* A2 = 0.995300 */
9136 -314, /* B2 = -0.009605 */
9137 0, /* B1 = 0.000000 */
9138 314, /* B0 = 0.009605 */
9139 31156, /* A1 = -1.901672 */
9140 -32694, /* A2 = 0.997742 */
9141 28847, /* B2 = 0.880371 */
9142 -2734, /* B1 = -0.166901 */
9143 28847, /* B0 = 0.880371 */
9144 31225, /* A1 = -1.905823 */
9145 -32696, /* A2 = 0.997803 */
9146 462, /* B2 = 0.014108 */
9147 -442, /* B1 = -0.027019 */
9148 462, /* B0 = 0.014108 */
9149 5, /* 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 { /* f400_425[] */
9155 30836, /* A1 = 1.882141 */
9156 -32296, /* A2 = -0.985596 */
9157 -324, /* B2 = -0.009903 */
9158 0, /* B1 = 0 */
9159 324, /* B0 = 0.009903 */
9160 30825, /* A1 = 1.881409 */
9161 -32570, /* A2 = -0.993958 */
9162 16847, /* B2 = 0.51416 */
9163 -15792, /* B1 = -0.963898 */
9164 16847, /* B0 = 0.51416 */
9165 31106, /* A1 = 1.89856 */
9166 -32584, /* A2 = -0.994415 */
9167 9579, /* B2 = 0.292328 */
9168 -9164, /* B1 = -0.559357 */
9169 9579, /* B0 = 0.292328 */
9170 7, /* 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 { /* f400_440[] */
9176 30702, /* A1 = 1.873962 */
9177 -32134, /* A2 = -0.980682 */
9178 -517, /* B2 = -0.015793 */
9179 0, /* B1 = 0 */
9180 517, /* B0 = 0.015793 */
9181 30676, /* A1 = 1.872375 */
9182 -32520, /* A2 = -0.992462 */
9183 8144, /* B2 = 0.24855 */
9184 -7596, /* B1 = -0.463684 */
9185 8144, /* B0 = 0.24855 */
9186 31084, /* A1 = 1.897217 */
9187 -32547, /* A2 = -0.993256 */
9188 22713, /* B2 = 0.693176 */
9189 -21734, /* B1 = -1.326599 */
9190 22713, /* B0 = 0.693176 */
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 { /* f400_450[] */
9197 30613, /* A1 = 1.86853 */
9198 -32031, /* A2 = -0.977509 */
9199 -618, /* B2 = -0.018866 */
9200 0, /* B1 = 0 */
9201 618, /* B0 = 0.018866 */
9202 30577, /* A1 = 1.866272 */
9203 -32491, /* A2 = -0.991577 */
9204 9612, /* B2 = 0.293335 */
9205 -8935, /* B1 = -0.54541 */
9206 9612, /* B0 = 0.293335 */
9207 31071, /* A1 = 1.896484 */
9208 -32524, /* A2 = -0.992584 */
9209 21596, /* B2 = 0.659058 */
9210 -20667, /* B1 = -1.261414 */
9211 21596, /* B0 = 0.659058 */
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 { /* f420 */
9218 30914, /* A1 = -1.886841 */
9219 -32584, /* A2 = 0.994385 */
9220 -426, /* B2 = -0.013020 */
9221 0, /* B1 = 0.000000 */
9222 426, /* B0 = 0.013020 */
9223 30914, /* A1 = -1.886841 */
9224 -32679, /* A2 = 0.997314 */
9225 17520, /* B2 = 0.534668 */
9226 -16471, /* B1 = -1.005310 */
9227 17520, /* B0 = 0.534668 */
9228 31004, /* A1 = -1.892334 */
9229 -32683, /* A2 = 0.997406 */
9230 819, /* B2 = 0.025023 */
9231 -780, /* B1 = -0.047619 */
9232 819, /* B0 = 0.025023 */
9233 5, /* 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 #if 0
9239 { /* f425 */
9240 30881, /* A1 = -1.884827 */
9241 -32603, /* A2 = 0.994965 */
9242 -496, /* B2 = -0.015144 */
9243 0, /* B1 = 0.000000 */
9244 496, /* B0 = 0.015144 */
9245 30880, /* A1 = -1.884766 */
9246 -32692, /* A2 = 0.997711 */
9247 24767, /* B2 = 0.755859 */
9248 -23290, /* B1 = -1.421509 */
9249 24767, /* B0 = 0.755859 */
9250 30967, /* A1 = -1.890076 */
9251 -32694, /* A2 = 0.997772 */
9252 728, /* B2 = 0.022232 */
9253 -691, /* B1 = -0.042194 */
9254 728, /* B0 = 0.022232 */
9255 5, /* Internal filter scaling */
9256 159, /* Minimum in-band energy threshold */
9257 21, /* 21/32 in-band to broad-band ratio */
9258 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9259 },
9260 #else
9261 {
9262 30850,
9263 -32534,
9264 -504,
9265 0,
9266 504,
9267 30831,
9268 -32669,
9269 24303,
9270 -22080,
9271 24303,
9272 30994,
9273 -32673,
9274 1905,
9275 -1811,
9276 1905,
9277 5,
9278 129,
9279 17,
9280 0xff5
9281 },
9282 #endif
9283 { /* f425_450[] */
9284 30646, /* A1 = 1.870544 */
9285 -32327, /* A2 = -0.986572 */
9286 -287, /* B2 = -0.008769 */
9287 0, /* B1 = 0 */
9288 287, /* B0 = 0.008769 */
9289 30627, /* A1 = 1.869324 */
9290 -32607, /* A2 = -0.995087 */
9291 13269, /* B2 = 0.404968 */
9292 -12376, /* B1 = -0.755432 */
9293 13269, /* B0 = 0.404968 */
9294 30924, /* A1 = 1.887512 */
9295 -32619, /* A2 = -0.995453 */
9296 19950, /* B2 = 0.608826 */
9297 -18940, /* B1 = -1.156006 */
9298 19950, /* B0 = 0.608826 */
9299 7, /* Internal filter scaling */
9300 159, /* Minimum in-band energy threshold */
9301 21, /* 21/32 in-band to broad-band ratio */
9302 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9303 },
9304 { /* f425_475[] */
9305 30396, /* A1 = 1.855225 */
9306 -32014, /* A2 = -0.97699 */
9307 -395, /* B2 = -0.012055 */
9308 0, /* B1 = 0 */
9309 395, /* B0 = 0.012055 */
9310 30343, /* A1 = 1.85199 */
9311 -32482, /* A2 = -0.991302 */
9312 17823, /* B2 = 0.543945 */
9313 -16431, /* B1 = -1.002869 */
9314 17823, /* B0 = 0.543945 */
9315 30872, /* A1 = 1.884338 */
9316 -32516, /* A2 = -0.99231 */
9317 18124, /* B2 = 0.553101 */
9318 -17246, /* B1 = -1.052673 */
9319 18124, /* B0 = 0.553101 */
9320 7, /* Internal filter scaling */
9321 159, /* Minimum in-band energy threshold */
9322 21, /* 21/32 in-band to broad-band ratio */
9323 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9324 },
9325 { /* f435 */
9326 30796, /* A1 = -1.879639 */
9327 -32603, /* A2 = 0.994965 */
9328 -254, /* B2 = -0.007762 */
9329 0, /* B1 = 0.000000 */
9330 254, /* B0 = 0.007762 */
9331 30793, /* A1 = -1.879456 */
9332 -32692, /* A2 = 0.997711 */
9333 18934, /* B2 = 0.577820 */
9334 -17751, /* B1 = -1.083496 */
9335 18934, /* B0 = 0.577820 */
9336 30882, /* A1 = -1.884888 */
9337 -32694, /* A2 = 0.997772 */
9338 1858, /* B2 = 0.056713 */
9339 -1758, /* B1 = -0.107357 */
9340 1858, /* B0 = 0.056713 */
9341 5, /* Internal filter scaling */
9342 159, /* Minimum in-band energy threshold */
9343 21, /* 21/32 in-band to broad-band ratio */
9344 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9345 },
9346 { /* f440_450[] */
9347 30641, /* A1 = 1.870239 */
9348 -32458, /* A2 = -0.99057 */
9349 -155, /* B2 = -0.004735 */
9350 0, /* B1 = 0 */
9351 155, /* B0 = 0.004735 */
9352 30631, /* A1 = 1.869568 */
9353 -32630, /* A2 = -0.995789 */
9354 11453, /* B2 = 0.349548 */
9355 -10666, /* B1 = -0.651001 */
9356 11453, /* B0 = 0.349548 */
9357 30810, /* A1 = 1.880554 */
9358 -32634, /* A2 = -0.995941 */
9359 12237, /* B2 = 0.373474 */
9360 -11588, /* B1 = -0.707336 */
9361 12237, /* B0 = 0.373474 */
9362 7, /* Internal filter scaling */
9363 159, /* Minimum in-band energy threshold */
9364 21, /* 21/32 in-band to broad-band ratio */
9365 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9366 },
9367 { /* f440_480[] */
9368 30367, /* A1 = 1.853455 */
9369 -32147, /* A2 = -0.981079 */
9370 -495, /* B2 = -0.015113 */
9371 0, /* B1 = 0 */
9372 495, /* B0 = 0.015113 */
9373 30322, /* A1 = 1.850769 */
9374 -32543, /* A2 = -0.993134 */
9375 10031, /* B2 = 0.306152 */
9376 -9252, /* B1 = -0.564728 */
9377 10031, /* B0 = 0.306152 */
9378 30770, /* A1 = 1.878052 */
9379 -32563, /* A2 = -0.993774 */
9380 22674, /* B2 = 0.691956 */
9381 -21465, /* B1 = -1.31012 */
9382 22674, /* B0 = 0.691956 */
9383 7, /* Internal filter scaling */
9384 159, /* Minimum in-band energy threshold */
9385 21, /* 21/32 in-band to broad-band ratio */
9386 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9387 },
9388 { /* f445 */
9389 30709, /* A1 = -1.874329 */
9390 -32603, /* A2 = 0.994965 */
9391 -83, /* B2 = -0.002545 */
9392 0, /* B1 = 0.000000 */
9393 83, /* B0 = 0.002545 */
9394 30704, /* A1 = -1.874084 */
9395 -32692, /* A2 = 0.997711 */
9396 10641, /* B2 = 0.324738 */
9397 -9947, /* B1 = -0.607147 */
9398 10641, /* B0 = 0.324738 */
9399 30796, /* A1 = -1.879639 */
9400 -32694, /* A2 = 0.997772 */
9401 10079, /* B2 = 0.307587 */
9402 9513, /* B1 = 0.580688 */
9403 10079, /* B0 = 0.307587 */
9404 5, /* Internal filter scaling */
9405 159, /* Minimum in-band energy threshold */
9406 21, /* 21/32 in-band to broad-band ratio */
9407 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9408 },
9409 { /* f450 */
9410 30664, /* A1 = -1.871643 */
9411 -32603, /* A2 = 0.994965 */
9412 -164, /* B2 = -0.005029 */
9413 0, /* B1 = 0.000000 */
9414 164, /* B0 = 0.005029 */
9415 30661, /* A1 = -1.871399 */
9416 -32692, /* A2 = 0.997711 */
9417 15294, /* B2 = 0.466736 */
9418 -14275, /* B1 = -0.871307 */
9419 15294, /* B0 = 0.466736 */
9420 30751, /* A1 = -1.876953 */
9421 -32694, /* A2 = 0.997772 */
9422 3548, /* B2 = 0.108284 */
9423 -3344, /* B1 = -0.204155 */
9424 3548, /* B0 = 0.108284 */
9425 5, /* Internal filter scaling */
9426 159, /* Minimum in-band energy threshold */
9427 21, /* 21/32 in-band to broad-band ratio */
9428 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9429 },
9430 { /* f452 */
9431 30653, /* A1 = -1.870911 */
9432 -32615, /* A2 = 0.995361 */
9433 -209, /* B2 = -0.006382 */
9434 0, /* B1 = 0.000000 */
9435 209, /* B0 = 0.006382 */
9436 30647, /* A1 = -1.870605 */
9437 -32702, /* A2 = 0.997986 */
9438 18971, /* B2 = 0.578979 */
9439 -17716, /* B1 = -1.081299 */
9440 18971, /* B0 = 0.578979 */
9441 30738, /* A1 = -1.876099 */
9442 -32702, /* A2 = 0.998016 */
9443 2967, /* B2 = 0.090561 */
9444 -2793, /* B1 = -0.170502 */
9445 2967, /* B0 = 0.090561 */
9446 5, /* 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 { /* f475 */
9452 30437, /* A1 = -1.857727 */
9453 -32603, /* A2 = 0.994965 */
9454 -264, /* B2 = -0.008062 */
9455 0, /* B1 = 0.000000 */
9456 264, /* B0 = 0.008062 */
9457 30430, /* A1 = -1.857300 */
9458 -32692, /* A2 = 0.997711 */
9459 21681, /* B2 = 0.661682 */
9460 -20082, /* B1 = -1.225708 */
9461 21681, /* B0 = 0.661682 */
9462 30526, /* A1 = -1.863220 */
9463 -32694, /* A2 = 0.997742 */
9464 1559, /* B2 = 0.047600 */
9465 -1459, /* B1 = -0.089096 */
9466 1559, /* B0 = 0.047600 */
9467 5, /* 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 { /* f480_620[] */
9473 28975, /* A1 = 1.768494 */
9474 -30955, /* A2 = -0.944672 */
9475 -1026, /* B2 = -0.03133 */
9476 0, /* B1 = 0 */
9477 1026, /* B0 = 0.03133 */
9478 28613, /* A1 = 1.746399 */
9479 -32089, /* A2 = -0.979309 */
9480 14214, /* B2 = 0.433807 */
9481 -12202, /* B1 = -0.744812 */
9482 14214, /* B0 = 0.433807 */
9483 30243, /* A1 = 1.845947 */
9484 -32238, /* A2 = -0.983856 */
9485 24825, /* B2 = 0.757629 */
9486 -23402, /* B1 = -1.428345 */
9487 24825, /* B0 = 0.757629 */
9488 7, /* 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 { /* f494 */
9494 30257, /* A1 = -1.846741 */
9495 -32605, /* A2 = 0.995056 */
9496 -249, /* B2 = -0.007625 */
9497 0, /* B1 = 0.000000 */
9498 249, /* B0 = 0.007625 */
9499 30247, /* A1 = -1.846191 */
9500 -32694, /* A2 = 0.997772 */
9501 18088, /* B2 = 0.552002 */
9502 -16652, /* B1 = -1.016418 */
9503 18088, /* B0 = 0.552002 */
9504 30348, /* A1 = -1.852295 */
9505 -32696, /* A2 = 0.997803 */
9506 2099, /* B2 = 0.064064 */
9507 -1953, /* B1 = -0.119202 */
9508 2099, /* B0 = 0.064064 */
9509 5, /* 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 { /* f500 */
9515 30202, /* A1 = -1.843431 */
9516 -32624, /* A2 = 0.995622 */
9517 -413, /* B2 = -0.012622 */
9518 0, /* B1 = 0.000000 */
9519 413, /* B0 = 0.012622 */
9520 30191, /* A1 = -1.842721 */
9521 -32714, /* A2 = 0.998364 */
9522 25954, /* B2 = 0.792057 */
9523 -23890, /* B1 = -1.458131 */
9524 25954, /* B0 = 0.792057 */
9525 30296, /* A1 = -1.849172 */
9526 -32715, /* A2 = 0.998397 */
9527 2007, /* B2 = 0.061264 */
9528 -1860, /* B1 = -0.113568 */
9529 2007, /* B0 = 0.061264 */
9530 5, /* 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 { /* f520 */
9536 30001, /* A1 = -1.831116 */
9537 -32613, /* A2 = 0.995270 */
9538 -155, /* B2 = -0.004750 */
9539 0, /* B1 = 0.000000 */
9540 155, /* B0 = 0.004750 */
9541 29985, /* A1 = -1.830200 */
9542 -32710, /* A2 = 0.998260 */
9543 6584, /* B2 = 0.200928 */
9544 -6018, /* B1 = -0.367355 */
9545 6584, /* B0 = 0.200928 */
9546 30105, /* A1 = -1.837524 */
9547 -32712, /* A2 = 0.998291 */
9548 23812, /* B2 = 0.726685 */
9549 -21936, /* B1 = -1.338928 */
9550 23812, /* B0 = 0.726685 */
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 { /* f523 */
9557 29964, /* A1 = -1.828918 */
9558 -32601, /* A2 = 0.994904 */
9559 -101, /* B2 = -0.003110 */
9560 0, /* B1 = 0.000000 */
9561 101, /* B0 = 0.003110 */
9562 29949, /* A1 = -1.827942 */
9563 -32700, /* A2 = 0.997925 */
9564 11041, /* B2 = 0.336975 */
9565 -10075, /* B1 = -0.614960 */
9566 11041, /* B0 = 0.336975 */
9567 30070, /* A1 = -1.835388 */
9568 -32702, /* A2 = 0.997986 */
9569 16762, /* B2 = 0.511536 */
9570 -15437, /* B1 = -0.942230 */
9571 16762, /* B0 = 0.511536 */
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 { /* f525 */
9578 29936, /* A1 = -1.827209 */
9579 -32584, /* A2 = 0.994415 */
9580 -91, /* B2 = -0.002806 */
9581 0, /* B1 = 0.000000 */
9582 91, /* B0 = 0.002806 */
9583 29921, /* A1 = -1.826233 */
9584 -32688, /* A2 = 0.997559 */
9585 11449, /* B2 = 0.349396 */
9586 -10426, /* B1 = -0.636383 */
9587 11449, /* B0 = 0.349396 */
9588 30045, /* A1 = -1.833862 */
9589 -32688, /* A2 = 0.997589 */
9590 13055, /* B2 = 0.398407 */
9591 -12028, /* B1 = -0.734161 */
9592 13055, /* B0 = 0.398407 */
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 { /* f540_660[] */
9599 28499, /* A1 = 1.739441 */
9600 -31129, /* A2 = -0.949982 */
9601 -849, /* B2 = -0.025922 */
9602 0, /* B1 = 0 */
9603 849, /* B0 = 0.025922 */
9604 28128, /* A1 = 1.716797 */
9605 -32130, /* A2 = -0.98056 */
9606 14556, /* B2 = 0.444214 */
9607 -12251, /* B1 = -0.747772 */
9608 14556, /* B0 = 0.444244 */
9609 29667, /* A1 = 1.81073 */
9610 -32244, /* A2 = -0.984039 */
9611 23038, /* B2 = 0.703064 */
9612 -21358, /* B1 = -1.303589 */
9613 23040, /* B0 = 0.703125 */
9614 7, /* 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 { /* f587 */
9620 29271, /* A1 = -1.786560 */
9621 -32599, /* A2 = 0.994873 */
9622 -490, /* B2 = -0.014957 */
9623 0, /* B1 = 0.000000 */
9624 490, /* B0 = 0.014957 */
9625 29246, /* A1 = -1.785095 */
9626 -32700, /* A2 = 0.997925 */
9627 28961, /* B2 = 0.883850 */
9628 -25796, /* B1 = -1.574463 */
9629 28961, /* B0 = 0.883850 */
9630 29383, /* A1 = -1.793396 */
9631 -32700, /* A2 = 0.997955 */
9632 1299, /* B2 = 0.039650 */
9633 -1169, /* B1 = -0.071396 */
9634 1299, /* B0 = 0.039650 */
9635 5, /* 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 { /* f590 */
9641 29230, /* A1 = -1.784058 */
9642 -32584, /* A2 = 0.994415 */
9643 -418, /* B2 = -0.012757 */
9644 0, /* B1 = 0.000000 */
9645 418, /* B0 = 0.012757 */
9646 29206, /* A1 = -1.782593 */
9647 -32688, /* A2 = 0.997559 */
9648 36556, /* B2 = 1.115601 */
9649 -32478, /* B1 = -1.982300 */
9650 36556, /* B0 = 1.115601 */
9651 29345, /* A1 = -1.791077 */
9652 -32688, /* A2 = 0.997589 */
9653 897, /* B2 = 0.027397 */
9654 -808, /* B1 = -0.049334 */
9655 897, /* B0 = 0.027397 */
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 { /* f600 */
9662 29116, /* A1 = -1.777100 */
9663 -32603, /* A2 = 0.994965 */
9664 -165, /* B2 = -0.005039 */
9665 0, /* B1 = 0.000000 */
9666 165, /* B0 = 0.005039 */
9667 29089, /* A1 = -1.775452 */
9668 -32708, /* A2 = 0.998199 */
9669 6963, /* B2 = 0.212494 */
9670 -6172, /* B1 = -0.376770 */
9671 6963, /* B0 = 0.212494 */
9672 29237, /* A1 = -1.784485 */
9673 -32710, /* A2 = 0.998230 */
9674 24197, /* B2 = 0.738464 */
9675 -21657, /* B1 = -1.321899 */
9676 24197, /* B0 = 0.738464 */
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 { /* f660 */
9683 28376, /* A1 = -1.731934 */
9684 -32567, /* A2 = 0.993896 */
9685 -363, /* B2 = -0.011102 */
9686 0, /* B1 = 0.000000 */
9687 363, /* B0 = 0.011102 */
9688 28337, /* A1 = -1.729614 */
9689 -32683, /* A2 = 0.997434 */
9690 21766, /* B2 = 0.664246 */
9691 -18761, /* B1 = -1.145081 */
9692 21766, /* B0 = 0.664246 */
9693 28513, /* A1 = -1.740356 */
9694 -32686, /* A2 = 0.997498 */
9695 2509, /* B2 = 0.076584 */
9696 -2196, /* B1 = -0.134041 */
9697 2509, /* B0 = 0.076584 */
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 { /* f700 */
9704 27844, /* A1 = -1.699463 */
9705 -32563, /* A2 = 0.993744 */
9706 -366, /* B2 = -0.011187 */
9707 0, /* B1 = 0.000000 */
9708 366, /* B0 = 0.011187 */
9709 27797, /* A1 = -1.696655 */
9710 -32686, /* A2 = 0.997498 */
9711 22748, /* B2 = 0.694214 */
9712 -19235, /* B1 = -1.174072 */
9713 22748, /* B0 = 0.694214 */
9714 27995, /* A1 = -1.708740 */
9715 -32688, /* A2 = 0.997559 */
9716 2964, /* B2 = 0.090477 */
9717 -2546, /* B1 = -0.155449 */
9718 2964, /* B0 = 0.090477 */
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 { /* f740 */
9725 27297, /* A1 = -1.666077 */
9726 -32551, /* A2 = 0.993408 */
9727 -345, /* B2 = -0.010540 */
9728 0, /* B1 = 0.000000 */
9729 345, /* B0 = 0.010540 */
9730 27240, /* A1 = -1.662598 */
9731 -32683, /* A2 = 0.997406 */
9732 22560, /* B2 = 0.688477 */
9733 -18688, /* B1 = -1.140625 */
9734 22560, /* B0 = 0.688477 */
9735 27461, /* A1 = -1.676147 */
9736 -32684, /* A2 = 0.997467 */
9737 3541, /* B2 = 0.108086 */
9738 -2985, /* B1 = -0.182220 */
9739 3541, /* B0 = 0.108086 */
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 { /* f750 */
9746 27155, /* A1 = -1.657410 */
9747 -32551, /* A2 = 0.993408 */
9748 -462, /* B2 = -0.014117 */
9749 0, /* B1 = 0.000000 */
9750 462, /* B0 = 0.014117 */
9751 27097, /* A1 = -1.653870 */
9752 -32683, /* A2 = 0.997406 */
9753 32495, /* B2 = 0.991699 */
9754 -26776, /* B1 = -1.634338 */
9755 32495, /* B0 = 0.991699 */
9756 27321, /* A1 = -1.667542 */
9757 -32684, /* A2 = 0.997467 */
9758 1835, /* B2 = 0.056007 */
9759 -1539, /* B1 = -0.093948 */
9760 1835, /* B0 = 0.056007 */
9761 5, /* 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 { /* f750_1450[] */
9767 19298, /* A1 = 1.177917 */
9768 -24471, /* A2 = -0.746796 */
9769 -4152, /* B2 = -0.126709 */
9770 0, /* B1 = 0 */
9771 4152, /* B0 = 0.126709 */
9772 12902, /* A1 = 0.787476 */
9773 -29091, /* A2 = -0.887817 */
9774 12491, /* B2 = 0.38121 */
9775 -1794, /* B1 = -0.109528 */
9776 12494, /* B0 = 0.381317 */
9777 26291, /* A1 = 1.604736 */
9778 -30470, /* A2 = -0.929901 */
9779 28859, /* B2 = 0.880737 */
9780 -26084, /* B1 = -1.592102 */
9781 28861, /* B0 = 0.880798 */
9782 7, /* 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 { /* f770 */
9788 26867, /* A1 = -1.639832 */
9789 -32551, /* A2 = 0.993408 */
9790 -123, /* B2 = -0.003755 */
9791 0, /* B1 = 0.000000 */
9792 123, /* B0 = 0.003755 */
9793 26805, /* A1 = -1.636108 */
9794 -32683, /* A2 = 0.997406 */
9795 17297, /* B2 = 0.527863 */
9796 -14096, /* B1 = -0.860382 */
9797 17297, /* B0 = 0.527863 */
9798 27034, /* A1 = -1.650085 */
9799 -32684, /* A2 = 0.997467 */
9800 12958, /* B2 = 0.395477 */
9801 -10756, /* B1 = -0.656525 */
9802 12958, /* B0 = 0.395477 */
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 { /* f800 */
9809 26413, /* A1 = -1.612122 */
9810 -32547, /* A2 = 0.993286 */
9811 -223, /* B2 = -0.006825 */
9812 0, /* B1 = 0.000000 */
9813 223, /* B0 = 0.006825 */
9814 26342, /* A1 = -1.607849 */
9815 -32686, /* A2 = 0.997498 */
9816 6391, /* B2 = 0.195053 */
9817 -5120, /* B1 = -0.312531 */
9818 6391, /* B0 = 0.195053 */
9819 26593, /* A1 = -1.623108 */
9820 -32688, /* A2 = 0.997559 */
9821 23681, /* B2 = 0.722717 */
9822 -19328, /* B1 = -1.179688 */
9823 23681, /* B0 = 0.722717 */
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 { /* f816 */
9830 26168, /* A1 = -1.597209 */
9831 -32528, /* A2 = 0.992706 */
9832 -235, /* B2 = -0.007182 */
9833 0, /* B1 = 0.000000 */
9834 235, /* B0 = 0.007182 */
9835 26092, /* A1 = -1.592590 */
9836 -32675, /* A2 = 0.997192 */
9837 20823, /* B2 = 0.635498 */
9838 -16510, /* B1 = -1.007751 */
9839 20823, /* B0 = 0.635498 */
9840 26363, /* A1 = -1.609070 */
9841 -32677, /* A2 = 0.997253 */
9842 6739, /* B2 = 0.205688 */
9843 -5459, /* B1 = -0.333206 */
9844 6739, /* B0 = 0.205688 */
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 { /* f850 */
9851 25641, /* A1 = -1.565063 */
9852 -32536, /* A2 = 0.992950 */
9853 -121, /* B2 = -0.003707 */
9854 0, /* B1 = 0.000000 */
9855 121, /* B0 = 0.003707 */
9856 25560, /* A1 = -1.560059 */
9857 -32684, /* A2 = 0.997437 */
9858 18341, /* B2 = 0.559753 */
9859 -14252, /* B1 = -0.869904 */
9860 18341, /* B0 = 0.559753 */
9861 25837, /* A1 = -1.577026 */
9862 -32684, /* A2 = 0.997467 */
9863 16679, /* B2 = 0.509003 */
9864 -13232, /* B1 = -0.807648 */
9865 16679, /* B0 = 0.509003 */
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 { /* f857_1645[] */
9872 16415, /* A1 = 1.001953 */
9873 -23669, /* A2 = -0.722321 */
9874 -4549, /* B2 = -0.138847 */
9875 0, /* B1 = 0 */
9876 4549, /* B0 = 0.138847 */
9877 8456, /* A1 = 0.516174 */
9878 -28996, /* A2 = -0.884918 */
9879 13753, /* B2 = 0.419724 */
9880 -12, /* B1 = -0.000763 */
9881 13757, /* B0 = 0.419846 */
9882 24632, /* A1 = 1.503418 */
9883 -30271, /* A2 = -0.923828 */
9884 29070, /* B2 = 0.887146 */
9885 -25265, /* B1 = -1.542114 */
9886 29073, /* B0 = 0.887268 */
9887 7, /* 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 { /* f900 */
9893 24806, /* A1 = -1.514099 */
9894 -32501, /* A2 = 0.991852 */
9895 -326, /* B2 = -0.009969 */
9896 0, /* B1 = 0.000000 */
9897 326, /* B0 = 0.009969 */
9898 24709, /* A1 = -1.508118 */
9899 -32659, /* A2 = 0.996674 */
9900 20277, /* B2 = 0.618835 */
9901 -15182, /* B1 = -0.926636 */
9902 20277, /* B0 = 0.618835 */
9903 25022, /* A1 = -1.527222 */
9904 -32661, /* A2 = 0.996735 */
9905 4320, /* B2 = 0.131836 */
9906 -3331, /* B1 = -0.203339 */
9907 4320, /* B0 = 0.131836 */
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 { /* f900_1300[] */
9914 19776, /* A1 = 1.207092 */
9915 -27437, /* A2 = -0.837341 */
9916 -2666, /* B2 = -0.081371 */
9917 0, /* B1 = 0 */
9918 2666, /* B0 = 0.081371 */
9919 16302, /* A1 = 0.995026 */
9920 -30354, /* A2 = -0.926361 */
9921 10389, /* B2 = 0.317062 */
9922 -3327, /* B1 = -0.203064 */
9923 10389, /* B0 = 0.317062 */
9924 24299, /* A1 = 1.483154 */
9925 -30930, /* A2 = -0.943909 */
9926 25016, /* B2 = 0.763428 */
9927 -21171, /* B1 = -1.292236 */
9928 25016, /* B0 = 0.763428 */
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 { /* f935_1215[] */
9935 20554, /* A1 = 1.254517 */
9936 -28764, /* A2 = -0.877838 */
9937 -2048, /* B2 = -0.062515 */
9938 0, /* B1 = 0 */
9939 2048, /* B0 = 0.062515 */
9940 18209, /* A1 = 1.11145 */
9941 -30951, /* A2 = -0.94458 */
9942 9390, /* B2 = 0.286575 */
9943 -3955, /* B1 = -0.241455 */
9944 9390, /* B0 = 0.286575 */
9945 23902, /* A1 = 1.458923 */
9946 -31286, /* A2 = -0.954803 */
9947 23252, /* B2 = 0.709595 */
9948 -19132, /* B1 = -1.167725 */
9949 23252, /* B0 = 0.709595 */
9950 7, /* 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 { /* f941_1477[] */
9956 17543, /* A1 = 1.07074 */
9957 -26220, /* A2 = -0.800201 */
9958 -3298, /* B2 = -0.100647 */
9959 0, /* B1 = 0 */
9960 3298, /* B0 = 0.100647 */
9961 12423, /* A1 = 0.75827 */
9962 -30036, /* A2 = -0.916626 */
9963 12651, /* B2 = 0.386078 */
9964 -2444, /* B1 = -0.14917 */
9965 12653, /* B0 = 0.386154 */
9966 23518, /* A1 = 1.435425 */
9967 -30745, /* A2 = -0.938293 */
9968 27282, /* B2 = 0.832581 */
9969 -22529, /* B1 = -1.375122 */
9970 27286, /* B0 = 0.832703 */
9971 7, /* 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 { /* f942 */
9977 24104, /* A1 = -1.471252 */
9978 -32507, /* A2 = 0.992065 */
9979 -351, /* B2 = -0.010722 */
9980 0, /* B1 = 0.000000 */
9981 351, /* B0 = 0.010722 */
9982 23996, /* A1 = -1.464600 */
9983 -32671, /* A2 = 0.997040 */
9984 22848, /* B2 = 0.697266 */
9985 -16639, /* B1 = -1.015564 */
9986 22848, /* B0 = 0.697266 */
9987 24332, /* A1 = -1.485168 */
9988 -32673, /* A2 = 0.997101 */
9989 4906, /* B2 = 0.149727 */
9990 -3672, /* B1 = -0.224174 */
9991 4906, /* B0 = 0.149727 */
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 { /* f950 */
9998 23967, /* A1 = -1.462830 */
9999 -32507, /* A2 = 0.992065 */
10000 -518, /* B2 = -0.015821 */
10001 0, /* B1 = 0.000000 */
10002 518, /* B0 = 0.015821 */
10003 23856, /* A1 = -1.456055 */
10004 -32671, /* A2 = 0.997040 */
10005 26287, /* B2 = 0.802246 */
10006 -19031, /* B1 = -1.161560 */
10007 26287, /* B0 = 0.802246 */
10008 24195, /* A1 = -1.476746 */
10009 -32673, /* A2 = 0.997101 */
10010 2890, /* B2 = 0.088196 */
10011 -2151, /* B1 = -0.131317 */
10012 2890, /* B0 = 0.088196 */
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 { /* f950_1400[] */
10019 18294, /* A1 = 1.116638 */
10020 -26962, /* A2 = -0.822845 */
10021 -2914, /* B2 = -0.088936 */
10022 0, /* B1 = 0 */
10023 2914, /* B0 = 0.088936 */
10024 14119, /* A1 = 0.861786 */
10025 -30227, /* A2 = -0.922455 */
10026 11466, /* B2 = 0.349945 */
10027 -2833, /* B1 = -0.172943 */
10028 11466, /* B0 = 0.349945 */
10029 23431, /* A1 = 1.430115 */
10030 -30828, /* A2 = -0.940796 */
10031 25331, /* B2 = 0.773071 */
10032 -20911, /* B1 = -1.276367 */
10033 25331, /* B0 = 0.773071 */
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 { /* f975 */
10040 23521, /* A1 = -1.435608 */
10041 -32489, /* A2 = 0.991516 */
10042 -193, /* B2 = -0.005915 */
10043 0, /* B1 = 0.000000 */
10044 193, /* B0 = 0.005915 */
10045 23404, /* A1 = -1.428467 */
10046 -32655, /* A2 = 0.996582 */
10047 17740, /* B2 = 0.541412 */
10048 -12567, /* B1 = -0.767029 */
10049 17740, /* B0 = 0.541412 */
10050 23753, /* A1 = -1.449829 */
10051 -32657, /* A2 = 0.996613 */
10052 9090, /* B2 = 0.277405 */
10053 -6662, /* B1 = -0.406647 */
10054 9090, /* B0 = 0.277405 */
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 { /* f1000 */
10061 23071, /* A1 = -1.408203 */
10062 -32489, /* A2 = 0.991516 */
10063 -293, /* B2 = -0.008965 */
10064 0, /* B1 = 0.000000 */
10065 293, /* B0 = 0.008965 */
10066 22951, /* A1 = -1.400818 */
10067 -32655, /* A2 = 0.996582 */
10068 5689, /* B2 = 0.173645 */
10069 -3951, /* B1 = -0.241150 */
10070 5689, /* B0 = 0.173645 */
10071 23307, /* A1 = -1.422607 */
10072 -32657, /* A2 = 0.996613 */
10073 18692, /* B2 = 0.570435 */
10074 -13447, /* B1 = -0.820770 */
10075 18692, /* B0 = 0.570435 */
10076 5, /* 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 { /* f1020 */
10082 22701, /* A1 = -1.385620 */
10083 -32474, /* A2 = 0.991058 */
10084 -292, /* B2 = -0.008933 */
10085 0, /*163840 , B1 = 10.000000 */
10086 292, /* B0 = 0.008933 */
10087 22564, /* A1 = -1.377258 */
10088 -32655, /* A2 = 0.996552 */
10089 20756, /* B2 = 0.633423 */
10090 -14176, /* B1 = -0.865295 */
10091 20756, /* B0 = 0.633423 */
10092 22960, /* A1 = -1.401428 */
10093 -32657, /* A2 = 0.996613 */
10094 6520, /* B2 = 0.198990 */
10095 -4619, /* B1 = -0.281937 */
10096 6520, /* B0 = 0.198990 */
10097 5, /* 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 { /* f1050 */
10103 22142, /* A1 = -1.351501 */
10104 -32474, /* A2 = 0.991058 */
10105 -147, /* B2 = -0.004493 */
10106 0, /* B1 = 0.000000 */
10107 147, /* B0 = 0.004493 */
10108 22000, /* A1 = -1.342834 */
10109 -32655, /* A2 = 0.996552 */
10110 15379, /* B2 = 0.469360 */
10111 -10237, /* B1 = -0.624847 */
10112 15379, /* B0 = 0.469360 */
10113 22406, /* A1 = -1.367554 */
10114 -32657, /* A2 = 0.996613 */
10115 17491, /* B2 = 0.533783 */
10116 -12096, /* B1 = -0.738312 */
10117 17491, /* B0 = 0.533783 */
10118 5, /* 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 { /* f1100_1750[] */
10124 12973, /* A1 = 0.79184 */
10125 -24916, /* A2 = -0.760376 */
10126 6655, /* B2 = 0.203102 */
10127 367, /* B1 = 0.0224 */
10128 6657, /* B0 = 0.203171 */
10129 5915, /* A1 = 0.361053 */
10130 -29560, /* A2 = -0.90213 */
10131 -7777, /* B2 = -0.23735 */
10132 0, /* B1 = 0 */
10133 7777, /* B0 = 0.23735 */
10134 20510, /* A1 = 1.251892 */
10135 -30260, /* A2 = -0.923462 */
10136 26662, /* B2 = 0.81366 */
10137 -20573, /* B1 = -1.255737 */
10138 26668, /* B0 = 0.813843 */
10139 7, /* 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 { /* f1140 */
10145 20392, /* A1 = -1.244629 */
10146 -32460, /* A2 = 0.990601 */
10147 -270, /* B2 = -0.008240 */
10148 0, /* B1 = 0.000000 */
10149 270, /* B0 = 0.008240 */
10150 20218, /* A1 = -1.234009 */
10151 -32655, /* A2 = 0.996582 */
10152 21337, /* B2 = 0.651154 */
10153 -13044, /* B1 = -0.796143 */
10154 21337, /* B0 = 0.651154 */
10155 20684, /* A1 = -1.262512 */
10156 -32657, /* A2 = 0.996643 */
10157 8572, /* B2 = 0.261612 */
10158 -5476, /* B1 = -0.334244 */
10159 8572, /* B0 = 0.261612 */
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 { /* f1200 */
10166 19159, /* A1 = -1.169373 */
10167 -32456, /* A2 = 0.990509 */
10168 -335, /* B2 = -0.010252 */
10169 0, /* B1 = 0.000000 */
10170 335, /* B0 = 0.010252 */
10171 18966, /* A1 = -1.157593 */
10172 -32661, /* A2 = 0.996735 */
10173 6802, /* B2 = 0.207588 */
10174 -3900, /* B1 = -0.238098 */
10175 6802, /* B0 = 0.207588 */
10176 19467, /* A1 = -1.188232 */
10177 -32661, /* A2 = 0.996765 */
10178 25035, /* B2 = 0.764008 */
10179 -15049, /* B1 = -0.918579 */
10180 25035, /* B0 = 0.764008 */
10181 5, /* 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 { /* f1209 */
10187 18976, /* A1 = -1.158264 */
10188 -32439, /* A2 = 0.989990 */
10189 -183, /* B2 = -0.005588 */
10190 0, /* B1 = 0.000000 */
10191 183, /* B0 = 0.005588 */
10192 18774, /* A1 = -1.145874 */
10193 -32650, /* A2 = 0.996429 */
10194 15468, /* B2 = 0.472076 */
10195 -8768, /* B1 = -0.535217 */
10196 15468, /* B0 = 0.472076 */
10197 19300, /* A1 = -1.177979 */
10198 -32652, /* A2 = 0.996490 */
10199 19840, /* B2 = 0.605499 */
10200 -11842, /* B1 = -0.722809 */
10201 19840, /* B0 = 0.605499 */
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 { /* f1330 */
10208 16357, /* A1 = -0.998413 */
10209 -32368, /* A2 = 0.987793 */
10210 -217, /* B2 = -0.006652 */
10211 0, /* B1 = 0.000000 */
10212 217, /* B0 = 0.006652 */
10213 16107, /* A1 = -0.983126 */
10214 -32601, /* A2 = 0.994904 */
10215 11602, /* B2 = 0.354065 */
10216 -5555, /* B1 = -0.339111 */
10217 11602, /* B0 = 0.354065 */
10218 16722, /* A1 = -1.020630 */
10219 -32603, /* A2 = 0.994965 */
10220 15574, /* B2 = 0.475311 */
10221 -8176, /* B1 = -0.499069 */
10222 15574, /* B0 = 0.475311 */
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 { /* f1336 */
10229 16234, /* A1 = -0.990875 */
10230 32404, /* A2 = -0.988922 */
10231 -193, /* B2 = -0.005908 */
10232 0, /* B1 = 0.000000 */
10233 193, /* B0 = 0.005908 */
10234 15986, /* A1 = -0.975769 */
10235 -32632, /* A2 = 0.995880 */
10236 18051, /* B2 = 0.550903 */
10237 -8658, /* B1 = -0.528473 */
10238 18051, /* B0 = 0.550903 */
10239 16591, /* A1 = -1.012695 */
10240 -32634, /* A2 = 0.995941 */
10241 15736, /* B2 = 0.480240 */
10242 -8125, /* B1 = -0.495926 */
10243 15736, /* B0 = 0.480240 */
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 { /* f1366 */
10250 15564, /* A1 = -0.949982 */
10251 -32404, /* A2 = 0.988922 */
10252 -269, /* B2 = -0.008216 */
10253 0, /* B1 = 0.000000 */
10254 269, /* B0 = 0.008216 */
10255 15310, /* A1 = -0.934479 */
10256 -32632, /* A2 = 0.995880 */
10257 10815, /* B2 = 0.330063 */
10258 -4962, /* B1 = -0.302887 */
10259 10815, /* B0 = 0.330063 */
10260 15924, /* A1 = -0.971924 */
10261 -32634, /* A2 = 0.995941 */
10262 18880, /* B2 = 0.576172 */
10263 -9364, /* B1 = -0.571594 */
10264 18880, /* B0 = 0.576172 */
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 { /* f1380 */
10271 15247, /* A1 = -0.930603 */
10272 -32397, /* A2 = 0.988708 */
10273 -244, /* B2 = -0.007451 */
10274 0, /* B1 = 0.000000 */
10275 244, /* B0 = 0.007451 */
10276 14989, /* A1 = -0.914886 */
10277 -32627, /* A2 = 0.995697 */
10278 18961, /* B2 = 0.578644 */
10279 -8498, /* B1 = -0.518707 */
10280 18961, /* B0 = 0.578644 */
10281 15608, /* A1 = -0.952667 */
10282 -32628, /* A2 = 0.995758 */
10283 11145, /* B2 = 0.340134 */
10284 -5430, /* B1 = -0.331467 */
10285 11145, /* B0 = 0.340134 */
10286 5, /* 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 { /* f1400 */
10292 14780, /* A1 = -0.902130 */
10293 -32393, /* A2 = 0.988586 */
10294 -396, /* B2 = -0.012086 */
10295 0, /* B1 = 0.000000 */
10296 396, /* B0 = 0.012086 */
10297 14510, /* A1 = -0.885651 */
10298 -32630, /* A2 = 0.995819 */
10299 6326, /* B2 = 0.193069 */
10300 -2747, /* B1 = -0.167671 */
10301 6326, /* B0 = 0.193069 */
10302 15154, /* A1 = -0.924957 */
10303 -32632, /* A2 = 0.995850 */
10304 23235, /* B2 = 0.709076 */
10305 -10983, /* B1 = -0.670380 */
10306 23235, /* B0 = 0.709076 */
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 { /* f1477 */
10313 13005, /* A1 = -0.793793 */
10314 -32368, /* A2 = 0.987823 */
10315 -500, /* B2 = -0.015265 */
10316 0, /* B1 = 0.000000 */
10317 500, /* B0 = 0.015265 */
10318 12708, /* A1 = -0.775665 */
10319 -32615, /* A2 = 0.995331 */
10320 11420, /* B2 = 0.348526 */
10321 -4306, /* B1 = -0.262833 */
10322 11420, /* B0 = 0.348526 */
10323 13397, /* A1 = -0.817688 */
10324 -32615, /* A2 = 0.995361 */
10325 9454, /* B2 = 0.288528 */
10326 -3981, /* B1 = -0.243027 */
10327 9454, /* B0 = 0.288528 */
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 { /* f1600 */
10334 10046, /* A1 = -0.613190 */
10335 -32331, /* A2 = 0.986694 */
10336 -455, /* B2 = -0.013915 */
10337 0, /* B1 = 0.000000 */
10338 455, /* B0 = 0.013915 */
10339 9694, /* A1 = -0.591705 */
10340 -32601, /* A2 = 0.994934 */
10341 6023, /* B2 = 0.183815 */
10342 -1708, /* B1 = -0.104279 */
10343 6023, /* B0 = 0.183815 */
10344 10478, /* A1 = -0.639587 */
10345 -32603, /* A2 = 0.994965 */
10346 22031, /* B2 = 0.672333 */
10347 -7342, /* B1 = -0.448151 */
10348 22031, /* B0 = 0.672333 */
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 { /* f1633_1638[] */
10355 9181, /* A1 = 0.560394 */
10356 -32256, /* A2 = -0.984375 */
10357 -556, /* B2 = -0.016975 */
10358 0, /* B1 = 0 */
10359 556, /* B0 = 0.016975 */
10360 8757, /* A1 = 0.534515 */
10361 -32574, /* A2 = -0.99408 */
10362 8443, /* B2 = 0.25769 */
10363 -2135, /* B1 = -0.130341 */
10364 8443, /* B0 = 0.25769 */
10365 9691, /* A1 = 0.591522 */
10366 -32574, /* A2 = -0.99411 */
10367 15446, /* B2 = 0.471375 */
10368 -4809, /* B1 = -0.293579 */
10369 15446, /* B0 = 0.471375 */
10370 7, /* 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 { /* f1800 */
10376 5076, /* A1 = -0.309875 */
10377 -32304, /* A2 = 0.985840 */
10378 -508, /* B2 = -0.015503 */
10379 0, /* B1 = 0.000000 */
10380 508, /* B0 = 0.015503 */
10381 4646, /* A1 = -0.283600 */
10382 -32605, /* A2 = 0.995026 */
10383 6742, /* B2 = 0.205780 */
10384 -878, /* B1 = -0.053635 */
10385 6742, /* B0 = 0.205780 */
10386 5552, /* A1 = -0.338928 */
10387 -32605, /* A2 = 0.995056 */
10388 23667, /* B2 = 0.722260 */
10389 -4297, /* B1 = -0.262329 */
10390 23667, /* B0 = 0.722260 */
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 { /* f1860 */
10397 3569, /* A1 = -0.217865 */
10398 -32292, /* A2 = 0.985504 */
10399 -239, /* B2 = -0.007322 */
10400 0, /* B1 = 0.000000 */
10401 239, /* B0 = 0.007322 */
10402 3117, /* A1 = -0.190277 */
10403 -32603, /* A2 = 0.994965 */
10404 18658, /* B2 = 0.569427 */
10405 -1557, /* B1 = -0.095032 */
10406 18658, /* B0 = 0.569427 */
10407 4054, /* A1 = -0.247437 */
10408 -32603, /* A2 = 0.994965 */
10409 18886, /* B2 = 0.576385 */
10410 -2566, /* B1 = -0.156647 */
10411 18886, /* B0 = 0.576385 */
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 };
10418 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10419 {
10420 unsigned short cmd;
10421 int cnt, max;
10422
10423 if (jf->filter > 3) {
10424 return -1;
10425 }
10426 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10427
10428 return -1;
10429 if (!jf->enable) {
10430 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10431
10432 return -1;
10433 else
10434 return 0;
10435 } else {
10436 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10437
10438 return -1;
10439 /* Select the filter (f0 - f3) to use. */
10440 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10441 return -1;
10442 }
10443 if (jf->freq < 12 && jf->freq > 3) {
10444 /* Select the frequency for the selected filter. */
10445 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10446 return -1;
10447 } else if (jf->freq > 11) {
10448 /* We need to load a programmable filter set for undefined */
10449 /* frequencies. So we will point the filter to a programmable set. */
10450 /* Since there are only 4 filters and 4 programmable sets, we will */
10451 /* just point the filter to the same number set and program it for the */
10452 /* frequency we want. */
10453 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10454 return -1;
10455 if (j->ver.low != 0x12) {
10456 cmd = 0x515B;
10457 max = 19;
10458 } else {
10459 cmd = 0x515E;
10460 max = 15;
10461 }
10462 if (ixj_WriteDSPCommand(cmd, j))
10463 return -1;
10464 for (cnt = 0; cnt < max; cnt++) {
10465 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10466 return -1;
10467 }
10468 }
10469 j->filter_en[jf->filter] = jf->enable;
10470 return 0;
10471 }
10472
10473 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10474 {
10475 unsigned short cmd;
10476 int cnt, max;
10477 if (jfr->filter > 3) {
10478 return -1;
10479 }
10480 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10481 return -1;
10482
10483 if (!jfr->enable) {
10484 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10485 return -1;
10486 else
10487 return 0;
10488 } else {
10489 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10490 return -1;
10491 /* Select the filter (f0 - f3) to use. */
10492 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10493 return -1;
10494 }
10495 /* We need to load a programmable filter set for undefined */
10496 /* frequencies. So we will point the filter to a programmable set. */
10497 /* Since there are only 4 filters and 4 programmable sets, we will */
10498 /* just point the filter to the same number set and program it for the */
10499 /* frequency we want. */
10500 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10501 return -1;
10502 if (j->ver.low != 0x12) {
10503 cmd = 0x515B;
10504 max = 19;
10505 } else {
10506 cmd = 0x515E;
10507 max = 15;
10508 }
10509 if (ixj_WriteDSPCommand(cmd, j))
10510 return -1;
10511 for (cnt = 0; cnt < max; cnt++) {
10512 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10513 return -1;
10514 }
10515 j->filter_en[jfr->filter] = jfr->enable;
10516 return 0;
10517 }
10518
10519 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10520 {
10521 int freq0, freq1;
10522 unsigned short data;
10523 if (ti->freq0) {
10524 freq0 = ti->freq0;
10525 } else {
10526 freq0 = 0x7FFF;
10527 }
10528
10529 if (ti->freq1) {
10530 freq1 = ti->freq1;
10531 } else {
10532 freq1 = 0x7FFF;
10533 }
10534
10535 if(ti->tone_index > 12 && ti->tone_index < 28)
10536 {
10537 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10538 return -1;
10539 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10540 return -1;
10541 data = freq0;
10542 if (ixj_WriteDSPCommand(data, j))
10543 return -1;
10544 data = freq1;
10545 if (ixj_WriteDSPCommand(data, j))
10546 return -1;
10547 }
10548 return freq0;
10549 }
10550
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree